@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/web-ui/app/controllers/automation-run-history.js

@@ -0,0 +1,159 @@
+const PAGE_SIZE = 50;
+const emptyFilters = () => ({ status: "", from: "", to: "" });
+
+function localDay(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(0);
+  date.setFullYear(year, month - 1, day);
+  date.setHours(0, 0, 0, 0);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day)
+    return null;
+  return date;
+}
+
+function historyQuery(filters) {
+  const query = { limit: PAGE_SIZE };
+  if (filters.status) query.status = filters.status;
+  const from = filters.from ? localDay(filters.from) : null;
+  const to = filters.to ? localDay(filters.to) : null;
+  if (filters.from && !from) throw new Error("Choose a valid start date.");
+  if (filters.to && !to) throw new Error("Choose a valid end date.");
+  if (to) to.setDate(to.getDate() + 1);
+  if (from && to && from >= to) throw new Error("The end date must be on or after the start date.");
+  if (from) query.from = from.toISOString();
+  if (to) query.to = to.toISOString();
+  return query;
+}
+
+export function automationRunPage(response) {
+  return {
+    runs: Array.isArray(response?.runs) ? response.runs : [],
+    runsNextCursor: typeof response?.nextCursor === "string" ? response.nextCursor : null,
+  };
+}
+
+function appendRunPage(runs, page) {
+  const entries = new Map(runs.map((run) => [run.id, run]));
+  for (const run of page) entries.set(run.id, run);
+  return [...entries.values()];
+}
+
+/** History belongs to an automation/environment, independently of its selected report. */
+export function createAutomationRunHistory({ state, client, getEnvironmentId, publish, errorLabel }) {
+  let revision = 0;
+  let loaded = false;
+  let pages = 0;
+  let failedRead = null;
+  let pendingFilters = null;
+
+  function resetScope() {
+    revision += 1;
+    loaded = false;
+    pages = 0;
+    failedRead = null;
+    pendingFilters = null;
+    Object.assign(state, { runs: [], runsNextCursor: null, runsLoading: false,
+      runsError: "", runsFilterError: "", runsFilters: emptyFilters() });
+  }
+
+  function captureScope() {
+    const environmentId = getEnvironmentId(), automationId = state.selectedAutomationId;
+    const capturedRevision = revision;
+    return { environmentId, automationId, isCurrent: () => capturedRevision === revision &&
+      environmentId === getEnvironmentId() && automationId === state.selectedAutomationId };
+  }
+
+  function canRefreshFirstPage(refresh) {
+    if (state.runsLoading) return false;
+    if (failedRead) return false;
+    if (!loaded) return true;
+    return refresh && pages < 2;
+  }
+
+  function captureRead({ refresh = false } = {}) {
+    const scope = captureScope();
+    const query = scope.automationId && canRefreshFirstPage(refresh) ? historyQuery(state.runsFilters) : null;
+    return { query, isCurrent: scope.isCurrent, accept(projection) {
+      if (!query || !scope.isCurrent()) return;
+      state.runs = projection.runs;
+      state.runsNextCursor = projection.runsNextCursor;
+      loaded = true;
+      pages = 1;
+    } };
+  }
+
+  async function readPage(filters, query, kind, isCurrent = () => true) {
+    revision += 1;
+    const scope = captureScope();
+    const canApplyHistoryRead = () => scope.isCurrent() && isCurrent();
+    failedRead = null;
+    pendingFilters = filters;
+    state.runsLoading = true;
+    state.runsError = "";
+    state.runsFilterError = "";
+    publish();
+    try {
+      const response = await client.listAutomationRuns(scope.automationId, scope.environmentId, query);
+      if (!canApplyHistoryRead()) return false;
+      const page = automationRunPage(response);
+      state.runs = kind === "more" ? appendRunPage(state.runs, page.runs) : page.runs;
+      state.runsNextCursor = page.runsNextCursor;
+      state.runsFilters = filters;
+      loaded = true;
+      pages = kind === "more" ? pages + 1 : 1;
+      return true;
+    } catch (error) {
+      if (!canApplyHistoryRead()) return false;
+      if (kind === "filter") {
+        state.runsFilterError = errorLabel(error);
+        return false;
+      }
+      state.runsError = errorLabel(error);
+      failedRead = { filters, query, kind };
+      return false;
+    } finally {
+      if (scope.isCurrent()) {
+        pendingFilters = null;
+        state.runsLoading = false;
+        publish();
+      }
+    }
+  }
+
+  async function setRunFilters(input) {
+    if (!state.selectedAutomationId) return false;
+    const filters = { status: input?.status || "", from: input?.from || "", to: input?.to || "" };
+    let query;
+    try { query = historyQuery(filters); }
+    catch (error) {
+      state.runsFilterError = errorLabel(error);
+      publish();
+      return false;
+    }
+    return readPage(filters, query, "filter");
+  }
+
+  function loadMoreRuns() {
+    if (!state.selectedAutomationId || !state.runsNextCursor || state.runsLoading) return false;
+    return readPage(state.runsFilters,
+      { ...historyQuery(state.runsFilters), cursor: state.runsNextCursor }, "more");
+  }
+
+  function resetRunHistory({ isCurrent = () => true, supersede = false } = {}) {
+    if (!state.selectedAutomationId || !isCurrent()) return false;
+    if (state.runsLoading && !supersede) return false;
+    const filters = pendingFilters || state.runsFilters;
+    return readPage(filters, historyQuery(filters), "reset", isCurrent);
+  }
+
+  function retryRunHistory() {
+    if (!failedRead || state.runsLoading) return false;
+    const { filters, query, kind } = failedRead;
+    return readPage(filters, query, kind);
+  }
+
+  resetScope();
+  return { resetScope, captureRead, revision: () => revision,
+    setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory };
+}

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

@@ -6,6 +6,7 @@ import { createAutomationDraftActions } from "./automation-draft-actions.js";
 import { createAutomationRunActions } from "./automation-run-actions.js";
 import { createAutomationViewCapture } from "./automation-view-scope.js";
 import { createAutomationManagementActions } from "./automation-management-actions.js";
+import { createAutomationRunHistory } from "./automation-run-history.js";
 import {
   automationProjectionChanged, readAutomationBackgroundProjection,
   readAutomationList, readAutomationSelection, validationResult,
@@ -31,7 +32,7 @@ export function createAutomationsController({
   isEditingDirty = () => false,
 }) {
   const state = {
-    automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+    automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "", lastViewedRunId: "",
     draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
     catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
     loading: false, mutation: "", error: "", feedback: "",
@@ -50,6 +51,8 @@ export function createAutomationsController({
   const snapshot = () => ({ ...state, draftUndo: draftActions?.undoState() || null,
     runStartPending: runActions?.isStartingRun() || false });
   const publish = () => render(snapshot());
+  const runHistory = createAutomationRunHistory({ state, client, getEnvironmentId, publish, errorLabel });
+  const { setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory } = runHistory;
   const currentEnvironment = (environmentId) => environmentId === getEnvironmentId();
   const captureView = createAutomationViewCapture({ state, getEnvironmentId,
     getNavigationRevision: () => navigationRevision, getNavigationRequestRevision: () => navigationRequestRevision,
@@ -61,7 +64,8 @@ export function createAutomationsController({
     currentEnvironment, captureView });
   const { mutateDraft, saveDefinition, saveNode, undoDraftMove, restorePublishedDraft } = draftActions;
   runActions = createAutomationRunActions({ client, mutation, publish,
-    loadSelected, openRun, captureView });
+    loadSelected, openRun, captureView,
+    refreshRunHistory: (isCurrent) => runHistory.resetRunHistory({ isCurrent, supersede: true }) });
   const { startRun, stopRun, rerun } = runActions;
   const { create, deleteDraft, publishDefinition, setActive, changeArchiveState, setPermission } =
     createAutomationManagementActions({ state, client, mutation, captureView,
@@ -86,14 +90,16 @@ export function createAutomationsController({
     state.stepEvidenceLoading = false;
     state.stepEvidenceError = "";
     if (automationChanged) {
+      state.lastViewedRunId = "";
       state.draft = null;
       state.publishedDefinition = null;
       state.grant = null;
       state.validation = null;
       state.validationVisible = false;
       state.catalog = null;
-      state.runs = [];
+      runHistory.resetScope();
     }
+    if (runId) state.lastViewedRunId = runId;
     navigationRevision += 1;
     onNavigationChange();
   }
@@ -123,19 +129,23 @@ export function createAutomationsController({
     }
   }
 
-  async function loadSelected(automationId, runId = "", isCurrent = () => true) {
+  async function loadSelected(automationId, runId = "", isCurrent = () => true, refreshRuns = false) {
     if (!isCurrent()) return false;
     const environmentId = getEnvironmentId();
     const revision = ++readRevision;
+    const historyRead = runHistory.captureRead({ refresh: refreshRuns });
     state.loading = true;
     state.error = "";
     publish();
     try {
-      const projection = await readAutomationSelection(client, automationId, runId, environmentId);
+      const projection = await readAutomationSelection(client, automationId, runId, environmentId,
+        { runsQuery: historyRead.query });
       if (!isCurrent()) return false;
       if (revision !== readRevision || !currentEnvironment(environmentId)) return false;
       if (state.selectedAutomationId !== automationId) return false;
-      Object.assign(state, projection);
+      const { runs, runsNextCursor, ...selection } = projection;
+      Object.assign(state, selection);
+      historyRead.accept({ runs, runsNextCursor });
       const selectedNodeId = selectedAutomationRunStepId(state.run, state.selectedNodeId);
       const initialStepSelected = selectedNodeId !== state.selectedNodeId;
       state.selectedNodeId = selectedNodeId;
@@ -181,7 +191,7 @@ export function createAutomationsController({
     const loadedList = await loadList(isCurrent);
     if (!loadedList || !isCurrent()) return false;
     if (!selected) return true;
-    const selectedLoaded = await loadSelected(selected, runId, isCurrent);
+    const selectedLoaded = await loadSelected(selected, runId, isCurrent, true);
     if (!selectedLoaded || !isCurrent()) return false;
     if (selectedLoaded && runId && state.selectedNodeId)
       await loadStepEvidence(runId, state.selectedNodeId, stepEvidenceFull, isCurrent);
@@ -193,24 +203,29 @@ export function createAutomationsController({
         state.mutation || isEditingDirty()) return false;
     if (!currentEnvironment(identity.environmentId) || identity.readRevision !== readRevision ||
         identity.navigationRevision !== navigationRevision || identity.mutationRevision !== mutationRevision ||
-        identity.evidenceRevision !== evidenceReadRevision) return false;
+        identity.evidenceRevision !== evidenceReadRevision ||
+        identity.historyRevision !== runHistory.revision()) return false;
     return state.selectedAutomationId === identity.automationId &&
       state.selectedRunId === identity.runId && state.selectedNodeId === identity.nodeId;
   }
 
   async function backgroundRefresh() {
+    const historyRead = runHistory.captureRead({ refresh: true });
     const identity = {
       environmentId: getEnvironmentId(), automationId: state.selectedAutomationId,
       runId: state.selectedRunId, nodeId: state.selectedNodeId,
       readRevision, navigationRevision, mutationRevision,
       evidenceRevision: evidenceReadRevision, full: stepEvidenceFull,
+      runsQuery: historyRead.query, historyRevision: runHistory.revision(),
     };
     if (!backgroundIdentityMatches(identity)) return false;
     try {
       const projection = await readAutomationBackgroundProjection(client, identity);
       if (!backgroundIdentityMatches(identity)) return false;
       if (!automationProjectionChanged(state, projection)) return true;
-      Object.assign(state, projection);
+      const { runs, runsNextCursor, ...selection } = projection;
+      Object.assign(state, selection);
+      historyRead.accept({ runs, runsNextCursor });
       publish();
       return true;
     } catch {
@@ -339,9 +354,10 @@ export function createAutomationsController({
     draftActions.clearUndo();
     readRevision += 1;
     loaded = false;
+    runHistory.resetScope();
     stepEvidenceFull = false;
     Object.assign(state, {
-      automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+      automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "", lastViewedRunId: "",
       draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
       catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
       loading: false, error: "", feedback: "",
@@ -364,12 +380,20 @@ export function createAutomationsController({
     eventRefresh.schedule();
   }
 
+  function captureActionScope() {
+    const continuation = captureView().captureContinuation();
+    const draftRevision = state.draft?.revision;
+    const publishedRevision = state.publishedDefinition?.revision;
+    return () => continuation.isCurrent() && draftRevision === state.draft?.revision &&
+      publishedRevision === state.publishedDefinition?.revision;
+  }
+
   return {
-    snapshot, openRoute, refresh, create,
+    snapshot, openRoute, refresh, create, captureActionScope,
     createTemplate: (templateId) => create(templateId), deleteDraft, mutateDraft, saveDefinition,
     saveNode, saveAgent, validate, publishDefinition, setActive, undoDraftMove, restorePublishedDraft,
     archive: () => changeArchiveState(true), restore: () => changeArchiveState(false),
-    setPermission, openRun,
+    setPermission, openRun, setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory,
     startRun, stopRun, rerun, environmentChanged, setWorkspaceActive, handleRealtime,
     showFullStepOutput() {
       if (!state.selectedRunId || !state.selectedNodeId) return false;

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

@@ -52,7 +52,7 @@ export interface ComposerFeatureOptions {
   recordControlEvent: ReturnType<typeof createRealtimeEventController>["recordControlEvent"];
   drafts?: ComposerDrafts;
   onChange?(): void;
-  confirmReview?(message: string): boolean;
+  confirmReview?(message: string, options?: { title: string; confirmLabel: string }): boolean | Promise<boolean>;
 }
 export interface ComposerFeature extends ComposerSurface {
   queue: ComposerQueueController;

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

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
 import { createComposerDrafts } from "./composer-drafts.js";
 import { createComposerSubmissionLifecycle, ComposerSubmissionRefused } from "./composer-submission-lifecycle.js";
 import { createComposerAttachmentsController } from "./composer-attachments-controller.js";
@@ -14,7 +15,7 @@ export function createComposerFeature({
   getSubmissionBlock, onSubmissionBlocked, isVisible = () => true,
   renderSessions, renderMessages, applyConversationChrome, setMessageStatus, recordControlEvent,
   drafts = createComposerDrafts(), onChange = () => {},
-  confirmReview = (message) => globalThis.confirm?.(message) === true,
+  confirmReview = confirmDialog,
 }) {
   const surfaces = [];
   let queue;
@@ -49,7 +50,12 @@ export function createComposerFeature({
       canDeleteAttachment: (file) => !drafts.contains(file) && !lifecycle.ownsAttachment(file) && !queue.ownsAttachment(file),
     });
     const notice = createComposerSubmissionNotice({ form: surfaceDom.composerForm, review: async (attempt) => {
-      if (!confirmReview("Check the conversation first: this message may already have been sent. Restore it for manual review? Sending it again may repeat its actions.")) return;
+      const draft = currentDraft();
+      const revision = draft.revision;
+      if (!await confirmReview("Check the conversation first: this message may already have been sent. Restore it for manual review? Sending it again may repeat its actions.",
+        { title: "Review paused message", confirmLabel: "Restore for review" })) return;
+      if (!visible() || currentDraft() !== draft || draft.revision !== revision) return;
+      if (!lifecycle.paused(draft.scope).includes(attempt)) return;
       try { await lifecycle.restoreForManualReview(attempt.id, queue.authorizeReview); }
       catch (error) { reportFailure(attempt.payload.scope, error.message); }
     }, recover: async (scope) => {
@@ -75,7 +81,8 @@ export function createComposerFeature({
     function send(action) {
       let draft = currentDraft();
       draft.text = surfaceDom.composerInput.value.trim();
-      const settings = getSettings();
+      const configured = getSettings();
+      const settings = { ...configured, ...(configured.reasoningPreference ? { reasoningPreference: { ...configured.reasoningPreference } } : {}) };
       if (!draft.scope.sessionId) { ensureBoundSession(); draft = currentDraft(); }
       const activeRequestId = allowsActiveRequest ? state.activeRequestId : "";
       return lifecycle.submit({ draft, action, settings,

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

@@ -22,7 +22,7 @@ export interface ComposerQueueControllerOptions {
   reportFailure(scope: ComposerScope, summary: string): void;
   reportRecovery?(scope: ComposerScope, summary: string): void;
   onChange?(): void;
-  confirmTakeover?(message: string): boolean;
+  confirmTakeover?(message: string, options?: { title: string; confirmLabel: string }): boolean | Promise<boolean>;
 }
 
 export interface ComposerQueueController {

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

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
 import { ComposerSubmissionRefused, isDefiniteSubmissionRefusal } from "./composer-submission-lifecycle.js";
 
 const scopeKey = (scope) => JSON.stringify([scope.environmentId, scope.sessionId]);
@@ -11,7 +12,7 @@ function hasConversationQueueScope(scope) {
 export function createComposerQueueController({
   queue, drafts, lifecycle, getDraft, requests, getSettings,
   isCurrentScope, reportFailure, reportRecovery = () => {}, onChange = () => {},
-  confirmTakeover = (message) => globalThis.confirm?.(message) === true,
+  confirmTakeover = confirmDialog,
 }) {
   const processing = new Map();
   const bindings = new Map();
@@ -112,8 +113,13 @@ export function createComposerQueueController({
     }
     let claimed = await queue.claimBlockedRelease(scope, release.releaseToken);
     if (!claimed) {
-      const approved = confirmTakeover("This queued message may have been sent or may belong to another window. Close that window and check the conversation before taking ownership for manual review. Sending it again may repeat its actions. Continue?");
+      if (!isCurrentScope(scope)) return false;
+      const revision = draft.revision;
+      const approved = await confirmTakeover("This queued message may have been sent or may belong to another window. Close that window and check the conversation before taking ownership for manual review. Sending it again may repeat its actions. Continue?",
+        { title: "Review queued message", confirmLabel: "Take ownership" });
       if (!approved) return false;
+      if (!isCurrentScope(scope) || draft.revision !== revision) return false;
+      if (queue.getBlockedRelease(scope)?.releaseToken !== release.releaseToken) return false;
       claimed = await queue.claimBlockedRelease(scope, release.releaseToken, { takeover: true });
     }
     if (!claimed) throw new Error("This queued message changed before it could be recovered.");
@@ -168,7 +174,7 @@ export function createComposerQueueController({
     const item = released.item;
     const attempt = await lifecycle.submitCaptured({
       action: "send", payload: { scope, text: item.text, attachments: item.attachments, release: released },
-      settings: { agentMode: item.agentMode, toolPermissionMode: item.toolPermissionMode, modelPreference: item.modelPreference },
+      settings: { agentMode: item.agentMode, toolPermissionMode: item.toolPermissionMode, modelPreference: item.modelPreference, ...(item.reasoningPreference ? { reasoningPreference: item.reasoningPreference } : {}) },
       prepare: async (submission) => { await prepareManualSend(submission); requests.prepareView(submission); },
       execute: send, accepted: bindAccepted, prepareRestore,
     });

package/dist/src/web-ui/app/controllers/composer-submission-lifecycle.d.ts

@@ -2,7 +2,7 @@ import type { SessionComposerQueueItem, ReleasedSessionComposerQueueItem } from
 import type { ComposerAttachment, ComposerDraft, ComposerDraftSnapshot, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
 
 export type ComposerSubmissionAction = "send" | "send_next" | "steer";
-export type ComposerSubmissionSettings = Pick<SessionComposerQueueItem, "agentMode" | "toolPermissionMode" | "modelPreference">;
+export type ComposerSubmissionSettings = Pick<SessionComposerQueueItem, "agentMode" | "toolPermissionMode" | "modelPreference" | "reasoningPreference">;
 export type ComposerSubmissionPhase = "preparing" | "sending" | "accepted" | "refused" | "uncertain" | "restored";
 
 export interface ComposerSubmissionAttempt<Settings = unknown, Result = unknown> {

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

@@ -11,16 +11,22 @@ export function createConversationWorkspaceActivation({ state, shell, composerQu
     const session = state.currentSessionId;
     const version = state.sessionViewVersion;
     const navigationRevision = shell.navigationRevision?.();
+    const navigationRequest = shell.navigationRequestRevision?.();
     const recovery = await composerQueue.prepareRecoveryForNavigation();
     if (!recovery || recovery.canCommit?.() === false) return false;
     if (!canNavigateConversation(state)) return false;
     const hasCurrentWorkspaceNavigation = navigationRevision === shell.navigationRevision?.();
     if (!hasCurrentWorkspaceNavigation) return false;
+    if (navigationRequest !== shell.navigationRequestRevision?.()) return false;
     if (environment !== selectedEnvironmentId()) return false;
     if (session !== state.currentSessionId) return false;
     if (version !== state.sessionViewVersion) return false;
-    const activate = shell.prepareWorkspaceActivation("chat", { focus: false });
-    if (!activate) return false;
+    const activate = await shell.prepareWorkspaceActivation("chat", { focus: false });
+    if (!activate || activate.canCommit?.() === false) return false;
+    if (environment !== selectedEnvironmentId()) return false;
+    if (session !== state.currentSessionId) return false;
+    if (version !== state.sessionViewVersion) return false;
+    if (recovery.canCommit?.() === false) return false;
     recovery();
     return activate() !== false;
   };

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

@@ -1,11 +1,7 @@
-function approvalIdentity(approval) {
-  return JSON.stringify([
-    approval.environmentId,
-    approval.sessionId,
-    approval.requestId,
-    approval.approvalId,
-  ]);
-}
+import {
+  approvalRejectionIdentity as approvalIdentity,
+  createApprovalRejectionDrafts,
+} from "../lib/tool-approval-rejection-drafts.js";
 
 export function createDashboardApprovalsController({
   client,
@@ -21,6 +17,7 @@ export function createDashboardApprovalsController({
   let scopeRevision = 0;
   let readRevision = 0;
   const submitting = new Set();
+  const rejectionDrafts = createApprovalRejectionDrafts();
 
   function snapshot() {
     return {
@@ -29,6 +26,7 @@ export function createDashboardApprovalsController({
           ? approvals.map((approval) => ({
               ...approval,
               submitted: submitting.has(approvalIdentity(approval)),
+              rejectionDraft: rejectionDrafts.get(approval),
             }))
           : [],
       supportsToolApprovals: client.supportsToolApprovals(),
@@ -58,6 +56,7 @@ export function createDashboardApprovalsController({
     error = "";
     decisionError = "";
     submitting.clear();
+    rejectionDrafts.clear();
   }
 
   async function refresh() {
@@ -79,6 +78,7 @@ export function createDashboardApprovalsController({
       const result = await client.listToolApprovals(scope);
       if (!hasCurrentRead(scope, revision)) return;
       approvals = result.approvals;
+      rejectionDrafts.retain(approvals);
       error = "";
     } catch (failure) {
       if (!hasCurrentRead(scope, revision)) return;
@@ -99,7 +99,7 @@ export function createDashboardApprovalsController({
     return approvals.some((pending) => approvalIdentity(pending) === identity);
   }
 
-  async function submit(approval, approved) {
+  async function submit(approval, approved, reason) {
     const identity = approvalIdentity(approval);
     if (!canSubmitApproval(approval, identity)) return false;
     const scope = approval.environmentId;
@@ -114,6 +114,7 @@ export function createDashboardApprovalsController({
         requestId: approval.requestId,
         approvalId: approval.approvalId,
         approved,
+        ...(reason !== undefined ? { reason } : {}),
         ...approvalDecisionCommand(approval, approved),
       });
       if (!hasCurrentScope(scope, revision)) return true;

package/dist/src/web-ui/app/controllers/environment-transition.js

@@ -53,9 +53,9 @@ export function createEnvironmentTransition({ state, dom, actions, prepareQueueR
       if (environmentChangeWasDeclined(preparedQueue)) { restoreSelection(); return false; }
       if (!canCommitEnvironmentPreparations([preparedAdditional, preparedQueue, commitEnvironmentOptions])) { restoreSelection(); return false; }
       const preparedConfig = actions.beforeEnvironmentChange
-        ? actions.beforeEnvironmentChange({ from: previous, to: target }) : true;
-      if (environmentChangeWasDeclined(preparedConfig)) { restoreSelection(); return false; }
+        ? await actions.beforeEnvironmentChange({ from: previous, to: target }) : true;
       if (!hasCurrentEnvironmentSelection(operation, previous)) return false;
+      if (environmentChangeWasDeclined(preparedConfig)) { restoreSelection(); return false; }
       if (!canCommitEnvironmentPreparations([preparedAdditional, preparedQueue, preparedConfig, commitEnvironmentOptions])) { restoreSelection(); return false; }
       if (typeof preparedAdditional === "function") preparedAdditional();
       if (typeof preparedQueue === "function") preparedQueue();

package/dist/src/web-ui/app/controllers/environment-workspace-preparation.js

@@ -1,16 +1,22 @@
 import { environmentChangeWasDeclined } from "./environment-transition.js";
 
-/** Discard configuration and schedule drafts only after both preparations remain current. */
-export function prepareEnvironmentWorkspaceChanges(schedules, configuration) {
-  const schedule = schedules.prepareEnvironmentChange();
+/** Discard workspace drafts only after every preparation remains current. */
+export async function prepareEnvironmentWorkspaceChanges(schedules, configuration, skills) {
+  const schedule = await schedules.prepareEnvironmentChange();
   if (environmentChangeWasDeclined(schedule)) return null;
-  const config = configuration.prepareDiscardChanges("change environment");
+  const config = await configuration.prepareDiscardChanges("change environment");
   if (environmentChangeWasDeclined(config)) return null;
+  const skill = skills ? await skills.prepareEnvironmentChange() : true;
+  if (environmentChangeWasDeclined(skill)) return null;
   const commit = () => {
-    if (typeof schedule === "function") schedule();
-    if (typeof config === "function") config();
+    if (!commit.canCommit()) return false;
+    for (const prepared of [skill, schedule, config]) {
+      if (typeof prepared === "function" && prepared() === false) return false;
+    }
+    return true;
   };
   commit.canCommit = () => {
+    if (skill?.canCommit?.() === false) return false;
     if (schedule?.canCommit?.() === false) return false;
     return config?.canCommit?.() !== false;
   };

package/dist/src/web-ui/app/controllers/preference-view-sync.js

@@ -0,0 +1,35 @@
+function sidebarPreferenceScope(preferences, environmentId) {
+  return JSON.stringify({
+    environmentId,
+    pinnedSessionIds: preferences.loadPinnedSessions(),
+    sidebar: preferences.loadSessionSidebar(environmentId),
+  });
+}
+
+/** Selection acknowledgements update controls, not the sidebar's loaded pages. */
+export function createPreferenceViewSync({
+  preferences, selection, dashboard, getEnvironmentId, loadSessions,
+}) {
+  let ready = false;
+  let sidebarScope;
+
+  function synchronize() {
+    selection.loadPreferences();
+    if (!ready) return;
+    selection.applyModelSelection();
+    selection.renderPermissionMode();
+    void dashboard.refresh();
+    const nextScope = sidebarPreferenceScope(preferences, getEnvironmentId());
+    if (nextScope === sidebarScope) return;
+    sidebarScope = nextScope;
+    void loadSessions();
+  }
+
+  return {
+    synchronize,
+    setReady() {
+      ready = true;
+      synchronize();
+    },
+  };
+}

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

@@ -13,6 +13,7 @@ export type ProjectCreationDraft = {
 
 export type ProjectsControllerState = {
   projects: readonly RuntimeProject[];
+  deletedProjectIds: readonly string[];
   loading: boolean;
   error: string;
   draft: ProjectCreationDraft | null;
@@ -30,6 +31,7 @@ export declare function createProjectsController(options: {
   onChange: (state: ProjectsControllerState) => void;
   notify: (message: string, tone: "failed") => void;
   onSessionCreated?: (sessionId: string) => void;
+  confirmAction?: (message: string) => boolean | Promise<boolean>;
 }): {
   snapshot(): ProjectsControllerState;
   load(): Promise<void>;
@@ -44,4 +46,6 @@ export declare function createProjectsController(options: {
   browse(directory?: string, cursor?: string): Promise<void>;
   create(): Promise<void>;
   newConversation(projectId: string): Promise<void>;
+  deleteProject(projectId: string, projectName?: string): Promise<boolean>;
+  getDeletedProjectIds(): readonly string[];
 };