@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/app/controllers/spark-chat-sync.js

@@ -1,15 +1,20 @@
 import { normalizeConversationMessage } from "./conversation-session-controller.js";
 import { rememberRequestLifecycle, sameConversationMessage } from "../lib/request-lifecycle-view.js";
 
-export function mergeSparkSnapshotMessages(snapshot, current) {
+export function mergeSparkSnapshotMessages(snapshot, current, hasNewer = false) {
   const canonical = (snapshot.messages || []).map(normalizeConversationMessage);
+  if (hasNewer) return current.map((message) => canonical.find((entry) => sameConversationMessage(message, entry)) || message);
   const activeRequestIds = new Set((snapshot.requests || []).filter((request) => request.status === "streaming").map((request) => request.requestId));
   const unsettled = current.filter((message) => {
     if (!message.streaming) return false;
     if (activeRequestIds.has(message.requestId)) return true;
     return !canonical.some((entry) => sameConversationMessage(message, entry));
   });
-  return [...canonical, ...unsettled];
+  if (snapshot.newerCursor === undefined) return [...canonical, ...unsettled];
+  const settled = current.filter((message) => !message.streaming);
+  const firstIndex = canonical.length ? settled.findIndex((message) => sameConversationMessage(message, canonical[0])) : -1;
+  const older = firstIndex >= 0 ? settled.slice(0, firstIndex) : [];
+  return [...older, ...canonical, ...unsettled];
 }
 
 function needsRequestLifecycleHydration(snapshot, state) {
@@ -64,6 +69,18 @@ export function createSparkChatSync({
     if (environmentId !== getEnvironmentId()) return false;
     return readRevision === revision;
   }
+  function canRetainTargetWindow(sessionId) {
+    if (!initialized || state.currentSessionId !== sessionId) return false;
+    return conversation.session.history?.hasNewer() === true;
+  }
+  async function hydrateConversation(result) {
+    if (!canRetainTargetWindow(result.sessionId)) {
+      await conversation.session.openSession(result.sessionId, { snapshot: { ...result.snapshot, readState: result.readState } });
+      return true;
+    }
+    state.messages = mergeSparkSnapshotMessages(result.snapshot, state.messages, true);
+    return conversation.session.rehydrateRequests(result.snapshot.requests || []);
+  }
   async function drain() {
     if (!canRefresh()) return;
     queued = false;
@@ -78,7 +95,7 @@ export function createSparkChatSync({
     try {
       const result = await client.loadSparkChat(environmentId);
       if (!isCurrentRead(environmentId, readRevision)) return;
-      if (modelCatalogEnvironment !== environmentId || !modelProfiles.some((profile) => profile.id === result.modelProfileId)) {
+      if (consolidateNext || modelCatalogEnvironment !== environmentId || !modelProfiles.some((profile) => profile.id === result.modelProfileId)) {
         const catalog = await client.listModels(environmentId);
         if (!isCurrentRead(environmentId, readRevision)) return;
         modelProfiles = catalog.profiles || catalog.models || [];
@@ -94,17 +111,19 @@ export function createSparkChatSync({
         onHistoryReset();
       }
       if (hasReadableGeneration(result.readState)) readGeneration = result.readState.readGeneration;
-      onConfiguration({ ...result, supportsImageInput, modelAvailable: Boolean(profile) });
+      onConfiguration({ ...result, supportsImageInput, supportsThinking: profile?.supportsThinking === true, modelAvailable: Boolean(profile) });
       onReadState(result.readState);
       const snapshot = result.snapshot;
       if (shouldHydrateSparkConversation(initialized, rehydrate, snapshot, state)) {
-        initialized = false; hydrating = true;
-        await conversation.session.openSession(result.sessionId);
+        hydrating = true;
+        const restored = await hydrateConversation(result);
         hydrating = false;
+        if (!restored) return;
         if (!isCurrentRead(environmentId, readRevision)) return;
         initialized = true;
       } else {
-        state.messages = mergeSparkSnapshotMessages(snapshot, state.messages);
+        conversation.session.history?.refresh(snapshot);
+        state.messages = mergeSparkSnapshotMessages(snapshot, state.messages, conversation.session.history?.hasNewer());
         for (const request of snapshot.requests || []) rememberRequestLifecycle(state, request.lifecycle);
         for (const message of state.messages) {
           if (message.role !== "assistant" || !message.requestId) continue;

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

@@ -1,3 +1,5 @@
+import { ComposerSubmissionRefused } from "./composer-submission-lifecycle.js";
+
 function createSteerId() {
   const randomId = globalThis.crypto?.randomUUID?.();
   if (randomId) return `web-steer-${randomId}`;
@@ -28,7 +30,7 @@ export function createSteerController({
     if (message.accepted === true) pending.resolve(message);
     else {
       pending.reject(
-        new Error(String(message.reason || "Steer was not accepted.")),
+        new ComposerSubmissionRefused(String(message.reason || "Steer was not accepted.")),
       );
     }
     return true;
@@ -43,13 +45,13 @@ export function createSteerController({
     }
   }
 
-  async function steer(text) {
-    const { requestId, environmentId, sessionId } = getScope();
+  async function steer(text, captured = {}) {
+    const { requestId, environmentId, sessionId } = captured.scope ?? getScope();
     if (!requestId || !sessionId) {
-      throw new Error("There is no active request to steer.");
+      throw new ComposerSubmissionRefused("There is no active request to steer.");
     }
-    if (getPendingAttachmentCount() > 0) {
-      throw new Error("Attachments can only be sent with Send next.");
+    if ((captured.pendingAttachmentCount ?? getPendingAttachmentCount()) > 0) {
+      throw new ComposerSubmissionRefused("Attachments can only be sent with Send next.");
     }
     const steerId = createSteerId();
     const acknowledgement = new Promise((resolve, reject) => {
@@ -81,7 +83,7 @@ export function createSteerController({
       const pending = pendingSteers.get(steerId);
       pendingSteers.delete(steerId);
       if (pending) clearTimer(pending.timeoutId);
-      throw new Error("Realtime connection is not available.");
+      throw new ComposerSubmissionRefused("Realtime connection is not available.");
     }
     await acknowledgement;
     const current = getScope();

package/dist/src/web-ui/app/controllers/tool-permission-mode-controller.js

@@ -20,7 +20,7 @@ export function createToolPermissionModeController({
   function currentToolPermissionMode() {
     const sessionId = getComposerSessionId();
     if (!sessionId) return preferences.loadLastToolPermissionMode(normalizeToolPermissionMode);
-    return normalizeToolPermissionMode(sessionModeFor(sessionId).toolPermissionMode);
+    return normalizeToolPermissionMode(sessionModeFor(sessionId).toolPermissionMode || "ask");
   }
 
   function clearSessionMode(sessionId) {

package/dist/src/web-ui/app/controllers/workspace-conversation-opener.js

@@ -0,0 +1,34 @@
+import { canNavigateConversation } from "./conversation-navigation-intent.js";
+
+/** Prepare the session and recovered draft before committing its workspace. */
+export function createWorkspaceConversationOpener({ state, shell, openSession }) {
+  return async (sessionId, options) => {
+    if (!sessionId) return false;
+    if (!canNavigateConversation(state)) {
+      shell.showToast?.("Wait for the environment change to finish before opening a conversation.", "neutral");
+      return false;
+    }
+    const activate = shell.prepareWorkspaceActivation("chat");
+    if (!activate) return false;
+    let navigationRevision = shell.navigationRevision?.();
+    function isConversationWorkspaceNavigationCurrent() {
+      if (!canNavigateConversation(state)) return false;
+      return shell.navigationRevision?.() === navigationRevision;
+    }
+    let committed = false;
+    const opened = await openSession(sessionId, {
+      ...options,
+      isRouteCurrent: isConversationWorkspaceNavigationCurrent,
+      commitRouteNavigation: () => {
+        if (!isConversationWorkspaceNavigationCurrent()) return false;
+        committed = activate() === true;
+        navigationRevision = shell.navigationRevision?.();
+        return committed;
+      },
+    });
+    if (opened !== true) return false;
+    if (!committed) return false;
+    if (!isConversationWorkspaceNavigationCurrent()) return false;
+    return state.currentSessionId === sessionId;
+  };
+}

package/dist/src/web-ui/app/controllers/workspace-route-controller.js

@@ -37,7 +37,7 @@ export function createWorkspaceRouteController({
       session: getSessionId(),
       automationRun: automations?.chatRunId() || "",
       category: configurationCategoryForWorkspace(shell.activeWorkspace()),
-      tab: shell.activeOperationsTab(),
+      tab: shell.activeWorkspace() === "plugins" ? configuration.activePluginTab?.() || "installed" : shell.activeOperationsTab(),
       job: schedules.selectedJobId(),
       automation: automations?.selectedAutomationId() || "",
       run: automations?.selectedRunId() || "",
@@ -136,24 +136,24 @@ export function createWorkspaceRouteController({
       return true;
     }
     if (route.session === getSessionId()) return true;
-    const sessions = await loadSessions();
+    await loadSessions();
     if (!routeActivationIsCurrent()) return false;
     if (environmentId !== getEnvironmentId()) return false;
-    if (!routeSessionIsListed(route, sessions)) {
-      shell.showToast(
-        "This conversation is unavailable in the selected environment.",
-        "failed",
-      );
+    let routeCommitted = false;
+    try {
+      await openSession(route.session, {
+        isRouteCurrent: routeActivationIsCurrent,
+        commitRouteNavigation: () => {
+          routeCommitted = commitLinkedConversationRoute();
+          return routeCommitted;
+        },
+      });
+    } catch (error) {
+      if (error.code !== "session_not_found") throw error;
+      if (!routeActivationIsCurrent()) return false;
+      shell.showToast("This conversation is unavailable in the selected environment.", "failed");
       return false;
     }
-    let routeCommitted = false;
-    await openSession(route.session, {
-      isRouteCurrent: routeActivationIsCurrent,
-      commitRouteNavigation: () => {
-        routeCommitted = commitLinkedConversationRoute();
-        return routeCommitted;
-      },
-    });
     if (!routeCommitted) return false;
     if (!routeActivationIsCurrent()) return false;
     if (environmentId !== getEnvironmentId()) return false;
@@ -223,6 +223,9 @@ export function createWorkspaceRouteController({
     if (route.workspace === "config") {
       shell.activateOperationsTab(route.tab || "runtime");
     }
+    if (route.workspace === "plugins") {
+      return configuration.openPluginRoute?.(route) ?? true;
+    }
     if (route.workspace === "schedules") {
       return await schedules.openJob(route.job || "");
     }
@@ -251,6 +254,9 @@ export function createWorkspaceRouteController({
         route.job = "";
         route.automation = "";
         route.run = "";
+        route.pluginSource = "";
+        route.pluginRef = "";
+        route.pluginPath = "";
       }
       await applyRoute(route, { initial: true });
     } catch (error) {
@@ -346,10 +352,6 @@ function routeChangesEnvironment(route, selectedEnvironment) {
   return route.environment !== selectedEnvironment;
 }
 
-function routeSessionIsListed(route, sessions) {
-  return sessions.some((session) => session.id === route.session);
-}
-
 function initialRouteWasSuperseded(initial, pendingHistory) {
   if (!initial) return false;
   return Boolean(pendingHistory);

package/dist/src/web-ui/app/dashboard-feature.js

@@ -1,3 +1,4 @@
+import { createWorkspaceConversationOpener } from "./controllers/workspace-conversation-opener.js";
 import { createDashboardWorkspace } from "./components/dashboard/workspace.js";
 import { createDashboardController } from "./controllers/dashboard-controller.js";
 import { createDashboardApprovalsController } from "./controllers/dashboard-approvals-controller.js";
@@ -17,6 +18,7 @@ export function createDashboardFeature({
   isComposerAvailable,
   passiveLearning,
 }) {
+  const openConversation = createWorkspaceConversationOpener({ state, shell, openSession });
   let view;
   let controller;
   const approvals = createDashboardApprovalsController({
@@ -34,7 +36,7 @@ export function createDashboardFeature({
     render: (snapshot) => {
       const sessions = filterSessionsByArchiveState(snapshot.sessions,
         preferences?.loadSessionSidebar?.(selectedEnvironmentId())?.archivedSessionIds);
-      view?.render({ ...snapshot, sessions, composerAvailable: isComposerAvailable() });
+      view?.render({ ...snapshot, sessions, sessionOverview: state.sessionOverview, composerAvailable: isComposerAvailable() });
     },
   });
   view = createDashboardWorkspace({
@@ -50,9 +52,8 @@ export function createDashboardFeature({
       refresh: controller.refresh,
       decideApproval: approvals.submit,
       openConversation: async (sessionId, requestId) => {
-        if (!shell.activateWorkspace("chat")) return;
         try {
-          await openSession(sessionId);
+          if (!await openConversation(sessionId, { page: { targetRequestId: requestId } })) return;
           if (state.currentSessionId !== sessionId) return;
           if (!requestId) return;
           requestAnimationFrame(() => {

package/dist/src/web-ui/app/index.html

@@ -25,7 +25,10 @@
     </section>
     <div id="app" class="app-shell" data-startup-pending aria-busy="true" inert>
       <nav class="workspace-rail" aria-label="Workspace navigation">
-        <div class="workspace-brand"><img src="/favicon.svg" width="28" height="28" alt="ABot" /></div>
+        <div class="workspace-brand">
+          <img src="/favicon.svg" width="28" height="28" alt="ABot" />
+          <a class="product-site-link" href="https://abot-ai.com/" target="_blank" rel="noopener noreferrer" aria-label="abot-ai.com — ABot website (opens in a new tab)">abot-ai.com <span aria-hidden="true">↗</span></a>
+        </div>
         <button
           id="sessionsToggleButton"
           class="rail-button rail-history-button"
@@ -314,6 +317,7 @@
           id="messagesList"
           class="messages-list"
           aria-label="Conversation messages"
+          tabindex="0"
         ></section>
         <div
           id="messageStatusRegion"
@@ -639,7 +643,7 @@
       >
         <header class="workspace-page-header config-workspace-header">
           <div class="workspace-page-heading config-workspace-heading">
-            <p class="eyebrow">Runtime workspace</p>
+            <a class="product-site-link" href="https://abot-ai.com/" target="_blank" rel="noopener noreferrer" aria-label="abot-ai.com — ABot website (opens in a new tab)">abot-ai.com <span aria-hidden="true">↗</span></a>
             <h2 id="configWorkspaceTitle">System</h2>
           </div>
           <div class="toolbar-actions">

package/dist/src/web-ui/app/lib/history-page-messages.js

@@ -0,0 +1,49 @@
+import { isApprovalPresentation, mergeConversationMessage, sameConversationMessage } from "./request-lifecycle-view.js";
+
+function isRequestResponse(message) {
+  if (message.role !== "assistant") return false;
+  if (!message.requestId) return false;
+  return !isApprovalPresentation(message);
+}
+
+function indexConversationMessages(messages) {
+  const byId = new Map(messages.map((message) => [message.id, message]));
+  const byRequest = new Map();
+  for (const message of messages) {
+    if (!isRequestResponse(message)) continue;
+    const candidates = byRequest.get(message.requestId) || [];
+    candidates.push(message);
+    byRequest.set(message.requestId, candidates);
+  }
+  return (incoming) => {
+    if (!incoming) return undefined;
+    const exact = byId.get(incoming.id);
+    if (exact) return exact;
+    return byRequest.get(incoming.requestId)?.find((message) => sameConversationMessage(message, incoming));
+  };
+}
+
+/** Keep the contiguous loaded history before rows received from the live stream. */
+export function mergeHistoryPage(state, incoming, direction, windowEnd) {
+  const current = state.messages;
+  const findCurrent = indexConversationMessages(current);
+  const replaced = new Set();
+  const page = incoming.map((message) => {
+    const existing = findCurrent(message);
+    if (!existing) return message;
+    replaced.add(existing);
+    return mergeConversationMessage(existing, message);
+  });
+  const retained = (messages) => messages.filter((message) => !replaced.has(message));
+  if (direction === "older") {
+    state.messages = [...page, ...retained(current)];
+  } else {
+    const end = current.indexOf(findCurrent(windowEnd));
+    const split = end < 0 ? current.length : end + 1;
+    state.messages = [...retained(current.slice(0, split)), ...page, ...retained(current.slice(split))];
+  }
+  for (const message of state.messages) {
+    if (!isRequestResponse(message)) continue;
+    state.requestMessages?.set(message.requestId, message.id);
+  }
+}

package/dist/src/web-ui/app/lib/reasoning-controls.js

@@ -0,0 +1,35 @@
+import { escapeHtml } from "./text-format.js";
+
+export function canChooseReasoning(profile) {
+  return profile?.supportsThinking === true;
+}
+
+/** Keep the stored mode for compatibility while showing the effective provider default. */
+export function reasoningModeOptions(mode, enabled, modes = ["fast", "reasoning", "deep"]) {
+  if (!enabled) return `<option value="${escapeHtml(mode || "reasoning")}">Provider default</option>`;
+  const labels = { fast: "Fast", reasoning: "Reasoning", deep: "Deep", auto: "Auto" };
+  return modes.map((value) => `<option value="${escapeHtml(value)}"${value === mode ? " selected" : ""}>${escapeHtml(labels[value] || value)}</option>`).join("");
+}
+
+export function renderReasoningModeField(mode, profile, modes) {
+  const enabled = canChooseReasoning(profile);
+  return `<label>Reasoning depth<select name="agentMode" data-reasoning-mode${enabled ? "" : " disabled"}>${reasoningModeOptions(mode, enabled, modes)}</select>
+    <small data-reasoning-mode-note${enabled ? " hidden" : ""}>Uses the provider default. Enable reasoning controls for this model in Models.</small></label>`;
+}
+
+export function syncReasoningModeField(form, profiles, modes) {
+  const select = form?.querySelector("[data-reasoning-mode]");
+  if (!select) return;
+  const profileId = form.querySelector('[name="modelProfileId"]')?.value;
+  const profile = profiles?.find((item) => item.id === profileId);
+  const enabled = canChooseReasoning(profile);
+  const mode = select.value;
+  select.innerHTML = reasoningModeOptions(mode, enabled, modes);
+  select.disabled = !enabled;
+  const note = form.querySelector("[data-reasoning-mode-note]");
+  if (note) note.hidden = enabled;
+}
+
+export function retainedReasoningMode(form, fallback) {
+  return form.querySelector("[data-reasoning-mode]")?.value || fallback;
+}

package/dist/src/web-ui/app/lib/request-lifecycle-view.js

@@ -71,6 +71,14 @@ export function sameConversationMessage(existing, incoming) {
   return !existing.persistedMessageId || !incoming.persistedMessageId;
 }
 
+export function mergeConversationMessage(existing, incoming) {
+  return {
+    ...existing, ...incoming,
+    text: incoming.text || existing.text,
+    thinkingText: incoming.thinkingText || existing.thinkingText,
+  };
+}
+
 export function removeStreamingPlaceholder(state, requestId) {
   state.messages = state.messages.filter((message) => {
     if (message.requestId !== requestId || message.role !== "assistant")

package/dist/src/web-ui/app/lib/session-composer-queue-ownership.js

@@ -0,0 +1,58 @@
+/** Persisted ownership has no expiry: uncertain sends require a manual handoff. */
+export function hasValidQueueOwnership(queue) {
+  const owner = queue.blockedReleaseOwner;
+  if (owner === undefined || owner === null) return true;
+  if (queue.blockedByReleaseToken === null) return false;
+  if (!owner || typeof owner !== "object" || Array.isArray(owner)) return false;
+  if (typeof owner.id !== "string" || !owner.id || owner.id.length > 128) return false;
+  return ["editing", "sending", "uncertain"].includes(owner.state);
+}
+
+export function canEditBlockedRelease(queue, ownerId) {
+  if (!queue.blockedReleaseOwner) return true;
+  if (queue.blockedReleaseOwner.id !== ownerId) return false;
+  return queue.blockedReleaseOwner.state === "editing";
+}
+
+export function canUpdateBlockedRelease(queue, ownerId) {
+  return canEditBlockedRelease(queue, ownerId);
+}
+
+export function canBindBlockedRelease(queue, ownerId) {
+  if (!queue.blockedReleaseOwner) return true;
+  if (queue.blockedReleaseOwner.id !== ownerId) return false;
+  return ["sending", "uncertain"].includes(queue.blockedReleaseOwner.state);
+}
+
+export function createQueueOwnership({ ownerId, readStore, writeStore, getQueue, createToken, projectRelease }) {
+  function claimBlockedRelease(scope, releaseToken, { takeover = false } = {}) {
+    if (!ownerId) return projectRelease(getQueue(readStore(), scope));
+    const store = readStore();
+    const queue = getQueue(store, scope);
+    if (!queue?.blockedReleaseItem || queue.blockedByReleaseToken !== releaseToken) return null;
+    const owner = queue.blockedReleaseOwner;
+    if (!takeover && owner && !canEditBlockedRelease(queue, ownerId)) return null;
+    if (takeover || !owner) queue.blockedByReleaseToken = createToken();
+    queue.blockedReleaseOwner = { id: ownerId, state: "editing" };
+    writeStore(store);
+    return projectRelease(queue);
+  }
+
+  function changeOwnedPhase(scope, releaseToken, from, to) {
+    if (!ownerId) return true;
+    const store = readStore();
+    const queue = getQueue(store, scope);
+    if (queue?.blockedByReleaseToken !== releaseToken) return false;
+    if (queue.blockedReleaseOwner?.id !== ownerId) return false;
+    if (queue.blockedReleaseOwner.state !== from) return false;
+    queue.blockedReleaseOwner.state = to;
+    writeStore(store);
+    return true;
+  }
+
+  return {
+    claimBlockedRelease,
+    beginBlockedSend: (scope, token) => changeOwnedPhase(scope, token, "editing", "sending"),
+    markBlockedUncertain: (scope, token) => changeOwnedPhase(scope, token, "sending", "uncertain"),
+  };
+}

package/dist/src/web-ui/app/lib/session-composer-queue.d.ts

@@ -32,9 +32,14 @@ export interface SessionComposerQueueStorage {
 export interface ReleasedSessionComposerQueueItem {
   item: SessionComposerQueueItem;
   releaseToken: string;
+  owner?: { id: string; state: "editing" | "sending" | "uncertain" };
 }
 
 export interface SessionComposerQueue {
+  refresh?(): Promise<void>;
+  claimBlockedRelease(scope: SessionComposerQueueScope, releaseToken: string, options?: { takeover?: boolean }): ReleasedSessionComposerQueueItem | null;
+  beginBlockedSend(scope: SessionComposerQueueScope, releaseToken: string): boolean;
+  markBlockedUncertain(scope: SessionComposerQueueScope, releaseToken: string): boolean;
   enqueue(
     scope: SessionComposerQueueScope,
     item: SessionComposerQueueItemInput,
@@ -64,12 +69,19 @@ export interface SessionComposerQueue {
   ): boolean;
 }
 
+type QueueMutation = "claimBlockedRelease" | "beginBlockedSend" | "markBlockedUncertain" | "enqueue" | "updateBlockedRelease" | "releaseForTerminal" | "bindReleasedSuccess" | "rebindBlocked";
+export type RemoteSessionComposerQueue = Omit<SessionComposerQueue, QueueMutation> & {
+  [K in QueueMutation]: (...args: Parameters<SessionComposerQueue[K]>) => Promise<ReturnType<SessionComposerQueue[K]>>;
+};
+
 export interface CreateSessionComposerQueueOptions {
+  ownerId?: string | null;
   storage?: SessionComposerQueueStorage;
   storageKey?: string;
 }
 
 export declare const SESSION_COMPOSER_QUEUE_STORAGE_KEY: string;
+export declare function isPersistedStore(value: unknown): boolean;
 
 export declare function createSessionComposerQueue(
   options?: CreateSessionComposerQueueOptions,

package/dist/src/web-ui/app/lib/session-composer-queue.js

@@ -1,3 +1,5 @@
+import { hasValidQueueOwnership, canUpdateBlockedRelease, canBindBlockedRelease, createQueueOwnership } from "./session-composer-queue-ownership.js";
+
 export const SESSION_COMPOSER_QUEUE_STORAGE_KEY =
   "abot-web.sessionComposerQueue.v1";
 
@@ -60,6 +62,7 @@ function isQueueRecord(value) {
   const blockedReleaseItem = value?.blockedReleaseItem ?? null;
   return Boolean(
     isRecord(value) &&
+    hasValidQueueOwnership(value) &&
     isNonEmptyString(value.environmentId) &&
     isNonEmptyString(value.sessionId) &&
     (value.blockedByReleaseToken === null ||
@@ -72,7 +75,7 @@ function isQueueRecord(value) {
   );
 }
 
-function isPersistedStore(value) {
+export function isPersistedStore(value) {
   if (
     !isRecord(value) ||
     value.version !== STORAGE_VERSION ||
@@ -149,7 +152,8 @@ function createReleaseToken() {
 }
 
 export function createSessionComposerQueue({
-  storage = globalThis.localStorage,
+  storage,
+  ownerId = null,
   storageKey = SESSION_COMPOSER_QUEUE_STORAGE_KEY,
 } = {}) {
   if (
@@ -210,9 +214,7 @@ export function createSessionComposerQueue({
     return list(scopeInput)[0] ?? null;
   }
 
-  function getBlockedRelease(scopeInput) {
-    const scope = validateScope(scopeInput);
-    const queue = findQueue(readStore(), scope);
+  function projectRelease(queue) {
     if (
       !queue ||
       queue.blockedByReleaseToken === null ||
@@ -223,9 +225,14 @@ export function createSessionComposerQueue({
     return {
       releaseToken: queue.blockedByReleaseToken,
       item: cloneJson(queue.blockedReleaseItem),
+      ...(queue.blockedReleaseOwner ? { owner: { ...queue.blockedReleaseOwner } } : {}),
     };
   }
 
+  function getBlockedRelease(scopeInput) {
+    return projectRelease(findQueue(readStore(), validateScope(scopeInput)));
+  }
+
   function updateBlockedRelease(scopeInput, releaseToken, itemInput) {
     const scope = validateScope(scopeInput);
     if (!isNonEmptyString(releaseToken)) return false;
@@ -239,6 +246,7 @@ export function createSessionComposerQueue({
     ) {
       return false;
     }
+    if (!canUpdateBlockedRelease(queue, ownerId)) return false;
     queue.blockedReleaseItem = item;
     writeStore(store);
     return true;
@@ -261,8 +269,9 @@ export function createSessionComposerQueue({
     const releaseToken = createReleaseToken();
     queue.blockedByReleaseToken = releaseToken;
     queue.blockedReleaseItem = item;
+    if (ownerId) queue.blockedReleaseOwner = { id: ownerId, state: "editing" };
     writeStore(store);
-    return { item: cloneJson(item), releaseToken };
+    return projectRelease(queue);
   }
 
   function bindReleasedSuccess(scopeInput, releaseToken, newRequestId) {
@@ -273,12 +282,14 @@ export function createSessionComposerQueue({
     const store = readStore();
     const queue = findQueue(store, scope);
     if (!queue || queue.blockedByReleaseToken !== releaseToken) return false;
+    if (!canBindBlockedRelease(queue, ownerId)) return false;
 
     if (queue.items[0]) {
       queue.items[0].waitForRequestId = newRequestId;
     }
     queue.blockedByReleaseToken = null;
     queue.blockedReleaseItem = null;
+    delete queue.blockedReleaseOwner;
     if (queue.items.length === 0) {
       store.queues = store.queues.filter((candidate) => candidate !== queue);
     }
@@ -292,12 +303,16 @@ export function createSessionComposerQueue({
     const store = readStore();
     const queue = findQueue(store, scope);
     if (!queue || queue.blockedByReleaseToken === null) return false;
+    // A request found in a snapshot is not proof that it belongs to this release.
+    if (queue.blockedReleaseOwner) return false;
+    if (queue.blockedReleaseItem?.waitForRequestId === newRequestId) return false;
 
     if (queue.items[0]) {
       queue.items[0].waitForRequestId = newRequestId;
     }
     queue.blockedByReleaseToken = null;
     queue.blockedReleaseItem = null;
+    delete queue.blockedReleaseOwner;
     if (queue.items.length === 0) {
       store.queues = store.queues.filter((candidate) => candidate !== queue);
     }
@@ -306,6 +321,10 @@ export function createSessionComposerQueue({
   }
 
   return {
+    ...createQueueOwnership({
+      ownerId, readStore, writeStore, createToken: createReleaseToken, projectRelease,
+      getQueue: (store, scope) => findQueue(store, validateScope(scope)),
+    }),
     enqueue,
     list,
     peek,

package/dist/src/web-ui/app/lib/workspace-route.d.ts

@@ -8,6 +8,9 @@ export interface WorkspaceRoute {
   job: string;
   automation: string;
   run: string;
+  pluginSource?: string;
+  pluginRef?: string;
+  pluginPath?: string;
 }
 
 export function readWorkspaceRoute(

package/dist/src/web-ui/app/lib/workspace-route.js

@@ -39,6 +39,7 @@ export function readWorkspaceRoute(location) {
     job: routeParameter(parameters, "job"),
     automation: routeParameter(parameters, "automation"),
     run: routeParameter(parameters, "run"),
+    ...(workspace === "plugins" && parameters.has("pluginSource") ? { pluginSource: routeParameter(parameters, "pluginSource"), pluginRef: routeParameter(parameters, "pluginRef"), pluginPath: routeParameter(parameters, "pluginPath") } : {}),
   };
 }
 
@@ -53,6 +54,9 @@ export function workspaceRouteUrl(route) {
     parameters.set("automationRun", route.automationRun);
   else if (workspace === "chat" && route.session)
     parameters.set("session", route.session);
+  if (workspace === "plugins") {
+    if (route.tab === "discover") parameters.set("tab", "discover");
+  }
   if (workspace === "config") {
     if (route.tab) parameters.set("tab", route.tab);
   }