@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -1,8 +1,18 @@
-import { captureComposerSubmissionScope, isCurrentComposerSubmissionScope } from "./lib/composer-submission-scope.js";
+import { isWorkspaceChange } from "./lib/workspace-change.js";
+import { createAppState } from "./app-state.js";
+import { createProjectsFeature } from "./projects-feature.js";
+import {
+  captureComposerSubmissionScope,
+  isCurrentComposerSubmissionScope,
+} from "./lib/composer-submission-scope.js";
 import { createComposerSurfaceController } from "./controllers/composer-surface-controller.js";
-import { bootstrapWebApp } from "./app-bootstrap.js";
-import { createConfigurationFeature } from "./configuration-feature.js";
+import { startWebApp } from "./app-bootstrap.js";
+import { createNotificationsFeature } from "./notifications-feature.js";
+import { bindWebAppWorkspaceLifecycle } from "./app-page-bindings.js";
+import { createConfigurationFeature } from "./configuration-environment-refresh.js";
+import { isConfigurationWorkspace } from "./lib/configuration-pages.js";
 import { createDashboardFeature } from "./dashboard-feature.js";
+import { createPassiveLearningFeature } from "./passive-learning-feature.js";
 import { createComposerWorkspaceController } from "./controllers/composer-workspace-controller.js";
 import { createHomeComposerFeature } from "./controllers/home-composer-feature.js";
 import { createHomeConversationActivation } from "./controllers/home-conversation-activation.js";
@@ -11,65 +21,29 @@ import { createSchedulesFeature } from "./schedules-feature.js";
 import { createWorkspaceShell } from "./components/workspace-shell.js";
 import { createComposerActions } from "./components/composer-actions.js";
 import { createModelSelector } from "./components/model-selector.js";
-import { createRuntimeSetupGuide } from "./components/runtime-setup-guide.js";
+import { createRuntimeOnboardingFeature } from "./runtime-onboarding-feature.js";
 import { createSessionActionsMenu } from "./components/session-actions-menu.js";
 import { createToolApprovalCard } from "./components/tool-approval-card.js";
 import { textOf } from "./lib/text-format.js";
-import { createConversationView } from "./components/conversation-view.js";
+import { createConversationViewFeature as createConversationView } from "./controllers/conversation-view-feature.js";
 import { createSessionComposerQueue } from "./lib/session-composer-queue.js";
 import { createRuntimeWebClient } from "./services/runtime-web-client.js";
 import { createClientPreferences } from "./services/client-preferences.js";
 import { createOperationsController } from "./controllers/operations-controller.js";
-import { createRealtimeTransport } from "./services/realtime-transport.js";
+import { createAppRealtimeTransport } from "./app-realtime-transport.js";
 import { createSteerController } from "./controllers/steer-controller.js";
 import { createSessionController } from "./controllers/session-controller.js";
 import { createComposerAttachmentsController } from "./controllers/composer-attachments-controller.js";
 import { createComposerQueueController } from "./controllers/composer-queue-controller.js";
 import { createRealtimeEventController } from "./controllers/realtime-event-controller.js";
 import { createRuntimeSelectionController } from "./controllers/runtime-selection-controller.js";
-import { createRuntimeOnboardingController } from "./controllers/runtime-onboarding-controller.js";
 import { createAppEventBindings } from "./controllers/app-event-bindings.js";
 import { createConversationSessionController } from "./controllers/conversation-session-controller.js";
 import { createChatRequestController } from "./controllers/chat-request-controller.js";
 import { createToolApprovalController } from "./controllers/tool-approval-controller.js";
 import { createComposerSubmitController } from "./controllers/composer-submit-controller.js";
 
-const state = {
-  config: null,
-  connected: false,
-  sessions: [],
-  pinnedSessionIds: [],
-  sessionModes: {},
-  sessionModels: {},
-  lastModelByEnvironment: {},
-  agentMode: "reasoning",
-  supportedAgentModes: ["fast", "reasoning", "deep", "auto"],
-  agentModeMenuOpen: false,
-  permissionModeMenuOpen: false,
-  agentPickerOpen: false,
-  busySessionIds: new Set(),
-  messages: [],
-  events: [],
-  taskProgressByRequest: new Map(),
-  contextWindowByRequest: new Map(),
-  submittedToolApprovalIds: new Set(),
-  requestMessages: new Map(),
-  currentSessionId: "",
-  activeRequestId: "",
-  sessionViewVersion: 0,
-  lastSeqByRequest: new Map(),
-  modelProfiles: [],
-  defaultModelProfileId: "",
-  runtimeAvailability: { status: "loading" },
-  pendingAttachments: [],
-  pendingAttachmentUploadCounts: new Map(),
-  composerAttachmentGeneration: 0,
-  composerSending: false,
-  composerQueueDrainingScopes: new Set(),
-  composerQueueRecoveredReleaseTokens: new Set(),
-  activeComposerQueueRecovery: null,
-  sessionQuery: "",
-};
+const state = createAppState();
 
 const dom = findAppDom();
 
@@ -87,41 +61,31 @@ let conversationView;
 let configWorkspace;
 let schedulesFeature;
 let dashboardFeature;
+let passiveLearning;
 let homeComposer;
 let runtimeSelection;
+let projectsFeature;
+let workspaceRoutes;
+let notifications;
 const operationsController = createOperationsController({
   dom,
   client: runtimeClient,
+  getEnvironmentId: selectedEnvironmentId,
 });
-const realtimeTransport = createRealtimeTransport({
+const realtimeTransport = createAppRealtimeTransport({
+  state,
   getConfig: () => state.config,
   onMessage: handleRealtimeMessage,
-  onOpen: () => {
-    state.connected = true;
-    setConnectionLabel("Connected");
+  setConnectionLabel,
+  rejectPendingSteers,
+  recordControlEvent,
+  onConnected: () => {
+    void dashboardFeature?.refresh();
+    schedulesFeature?.reconnect();
+    passiveLearning?.reconnect();
+    notifications?.reconnect();
     if (state.currentSessionId) subscribeSession(state.currentSessionId);
   },
-  onClose: () => {
-    state.connected = false;
-    rejectPendingSteers(
-      "Realtime connection closed before steer was accepted.",
-    );
-    setConnectionLabel("Reconnecting", true);
-  },
-  onError: () => {
-    state.connected = false;
-    setConnectionLabel("Connection issue", true);
-  },
-  onParseError: (error, preview) => {
-    recordControlEvent({
-      type: "control",
-      name: "Realtime parse error",
-      tone: "failed",
-      summary: `${error instanceof Error ? error.message : String(error)}${
-        preview ? `: ${preview}` : ""
-      }`,
-    });
-  },
 });
 const steerController = createSteerController({
   sendRealtime,
@@ -136,13 +100,22 @@ const steerController = createSteerController({
 
 const shell = createWorkspaceShell({
   dom,
-  isWorkspaceAvailable: (destination) =>
-    schedulesFeature?.isWorkspaceAvailable(destination) ?? false,
+  onNavigationChange: () => workspaceRoutes?.sync(),
+  isWorkspaceAvailable: (destination) => {
+    if (!notifications?.isWorkspaceAvailable(destination)) return false;
+    return schedulesFeature?.isWorkspaceAvailable(destination) ?? false;
+  },
   onWorkspaceChange: (workspace) => {
     runtimeSelection?.rememberModelSelection();
     homeComposer?.setWorkspace(workspace);
+    conversationView?.setWorkspace(workspace);
+    projectsFeature?.workspaceChanged(workspace);
+    runtimeSetupGuide.clearSecret();
     schedulesFeature?.setActive(workspace === "schedules");
     dashboardFeature?.setActive(workspace === "home");
+    passiveLearning?.setWorkspace(workspace);
+    notifications?.workspaceChanged(workspace);
+    configWorkspace?.setWorkspace(workspace);
     runtimeSelection?.applyModelSelection();
     runtimeSelection?.renderPermissionMode();
     renderAttachmentComposer();
@@ -152,28 +125,31 @@ const shell = createWorkspaceShell({
   beforeWorkspaceChange: ({ from, to }) => {
     if (from === "schedules" && to !== "schedules")
       return schedulesFeature?.prepareLeave() ?? true;
-    if (from !== "config" || to === "config") return true;
+    if (!isConfigurationWorkspace(from) || from === to) return true;
     if (!configWorkspace) return true;
     return configWorkspace.prepareDiscardChanges("leave configuration");
   },
 });
-const runtimeSetupGuide = createRuntimeSetupGuide({
-  container: dom.runtimeSetupGuide,
-  conversationRegion: dom.messagesList,
-  copyText: (value) => navigator.clipboard.writeText(value),
-  getSetupCommandMode: () => state.config?.setupCommandMode,
-});
-const runtimeOnboarding = createRuntimeOnboardingController({
-  state,
-  guide: runtimeSetupGuide,
-  reloadModels: loadModels,
-  setMessageStatus: setMessageActivityStatus,
-  onStateChange: () => {
-    updateComposerSendState();
-    renderAttachmentComposer();
-    dashboardFeature?.publish();
-  },
+notifications = createNotificationsFeature({
+  dom, state, client: runtimeClient, shell, getEnvironmentId: selectedEnvironmentId, send: sendRealtime,
 });
+const { guide: runtimeSetupGuide, controller: runtimeOnboarding } =
+  createRuntimeOnboardingFeature({
+    dom, shell,
+    runtimeClient,
+    selectedEnvironmentId,
+    state,
+    reloadModels: () => configWorkspace.reloadAppliedEnvironmentModels(),
+    reloadCatalog: loadModels,
+    setMessageStatus: setMessageActivityStatus,
+    onStateChange: () => {
+      updateComposerSendState();
+      renderAttachmentComposer();
+      dashboardFeature?.runtimeAvailabilityChanged();
+      schedulesFeature?.runtimeAvailabilityChanged();
+      configWorkspace?.renderHomeGuidance();
+    },
+  });
 
 const composerActions = createComposerActions({
   dom,
@@ -181,16 +157,33 @@ const composerActions = createComposerActions({
 });
 schedulesFeature = createSchedulesFeature({
   dom,
+  onNavigationChange: () => workspaceRoutes?.sync(),
   client: runtimeClient,
   shell,
   selectedEnvironmentId,
   getCurrentSessionId: () => state.currentSessionId,
   getAgentModes: () => state.supportedAgentModes,
+  isRuntimeReady: runtimeOnboarding.isReady,
   openSession: (sessionId) => conversationSession.openSession(sessionId),
 });
+passiveLearning = createPassiveLearningFeature({
+  onChange: () => configWorkspace?.renderHomeGuidance(),
+  client: runtimeClient,
+  openSession: (sessionId) => conversationSession.openSession(sessionId),
+  activateChat: () => shell.activateWorkspace("chat"),
+  getEnvironmentId: selectedEnvironmentId,
+  learningRoot: dom.learningRoot,
+  openLearning: () => shell.activateWorkspace("learning"),
+  openComputerAccess: () => configWorkspace?.openComputerSetup(),
+  showActivityMemories: () => {
+    if (shell.activateWorkspace("memory"))
+      configWorkspace?.showActivityMemories();
+  },
+});
 dashboardFeature = createDashboardFeature({
   dom,
   state,
+  preferences,
   client: runtimeClient,
   shell,
   schedules: schedulesFeature,
@@ -198,8 +191,11 @@ dashboardFeature = createDashboardFeature({
   loadSessions,
   openSession: (sessionId) => conversationSession.openSession(sessionId),
   isComposerAvailable: runtimeOnboarding.isReady,
+  passiveLearning,
 });
 const composerWorkspace = createComposerWorkspaceController({
+  onSessionCreated: (sessionId) =>
+    runtimeSelection.initializeSessionMode(sessionId),
   state,
   dom,
   homeComposerHost: dashboardFeature.composerHost,
@@ -230,7 +226,9 @@ const sessionActionsMenu = createSessionActionsMenu({
 const sessionController = createSessionController({
   state,
   dom,
+  onSidebarChange: renderSessions,
   sessionActionsMenu,
+  renderGroups: (input) => projectsFeature?.renderSessionGroups(input) ?? false,
   shell,
   preferences,
   client: runtimeClient,
@@ -276,12 +274,13 @@ const toolApprovalController = createToolApprovalController({
   createCard: createToolApprovalCard,
 });
 conversationView = createConversationView({
-  dom: {
-    messagesList: dom.messagesList,
-    jumpToLatestButton: dom.jumpToLatestButton,
-    composerContextWindow: dom.composerContextWindow,
-    composerPlan: dom.composerPlan,
-  },
+  dom,
+  filePreviewClient: runtimeClient,
+  preferences,
+  archiveSession: (sessionId) => sessionController.archiveSession(sessionId),
+  onSparkArchived: () => shell.activateWorkspace("home"),
+  getFileEnvironmentId: selectedEnvironmentId,
+  getFileSessionId: () => state.currentSessionId,
   getMessages: () => state.messages,
   getActiveRequestId: () => state.activeRequestId,
   isConnected: () => state.connected,
@@ -293,6 +292,7 @@ conversationView = createConversationView({
       state.contextWindowByRequest.get(textOf(message.requestId)) || null,
   }),
   getPendingApproval: toolApprovalController.pendingEvent,
+  getPendingApprovals: toolApprovalController.pendingEvents,
   createApprovalCard: toolApprovalController.createCard,
   copyText: (text) => navigator.clipboard.writeText(text),
   notify: (message, tone) => shell.showToast(message, tone),
@@ -301,6 +301,8 @@ conversationView = createConversationView({
   canOpenSchedule: runtimeClient.supportsSchedules,
 });
 conversationSession = createConversationSessionController({
+  onSessionCreated: (sessionId) =>
+    runtimeSelection.initializeSessionMode(sessionId),
   state,
   dom,
   client: runtimeClient,
@@ -335,6 +337,24 @@ conversationSession = createConversationSessionController({
   isCurrentComposerScope: (scope) =>
     composerQueueController.isCurrentScope(scope),
 });
+projectsFeature = createProjectsFeature({
+  onSessionCreated: (sessionId) =>
+    runtimeSelection.initializeSessionMode(sessionId),
+  dom,
+  state,
+  client: runtimeClient,
+  shell,
+  selectedEnvironmentId,
+  conversationSession,
+  renderSessions,
+  closeFilePreview: conversationView.closeFilePreview,
+  prepareConversation: () => {
+    const activate = shell.prepareWorkspaceActivation("chat", { focus: false });
+    if (!activate) return false;
+    if (!composerQueueController.suspendRecoveryForNavigation()) return false;
+    return activate() !== false;
+  },
+});
 chatRequests = createChatRequestController({
   state,
   client: runtimeClient,
@@ -405,13 +425,11 @@ realtimeEvents = createRealtimeEventController({
   scheduleThinkingRender,
   cancelScheduledMessageRender,
   cancelScheduledThinkingRender,
-  forgetThinkingDisclosure: (messageId) =>
-    conversationView.forgetThinkingDisclosure(messageId),
   markCurrentSessionReadSoon: conversationSession.markCurrentSessionReadSoon,
   applySessionTitleUpdate: conversationSession.applySessionTitleUpdate,
   setMessageActivityStatus,
   updateComposerSendState,
-  drainQueuedComposerMessage,
+  drainQueuedComposerMessage: (scope) => composerQueueController.drain(scope),
   loadSessions: conversationSession.loadSessions,
 });
 
@@ -472,16 +490,24 @@ homeComposer = createHomeComposerFeature({
     updateComposerSendState,
   }),
   sendMessage: async (text) => {
-    const scope = captureComposerSubmissionScope(state, selectedEnvironmentId());
+    const scope = captureComposerSubmissionScope(
+      state,
+      selectedEnvironmentId(),
+    );
     state.composerSending = true;
     updateComposerSendState();
     try {
       await chatRequests.sendMessage(text);
     } catch (error) {
-      if (!isCurrentComposerSubmissionScope(scope, state, selectedEnvironmentId())) return;
+      if (
+        !isCurrentComposerSubmissionScope(scope, state, selectedEnvironmentId())
+      )
+        return;
       conversationSession.appendRequestError(error);
     } finally {
-      if (isCurrentComposerSubmissionScope(scope, state, selectedEnvironmentId())) {
+      if (
+        isCurrentComposerSubmissionScope(scope, state, selectedEnvironmentId())
+      ) {
         state.composerSending = false;
         updateComposerSendState();
       }
@@ -489,6 +515,9 @@ homeComposer = createHomeComposerFeature({
   },
 });
 const appEventBindings = createAppEventBindings({
+  onNavigationChange: () => workspaceRoutes?.sync(),
+  onSessionCreated: (sessionId) =>
+    runtimeSelection.initializeSessionMode(sessionId),
   state,
   dom,
   shell,
@@ -535,6 +564,12 @@ const appEventBindings = createAppEventBindings({
 });
 
 configWorkspace = createConfigurationFeature({
+  getLearningSnapshot: () => passiveLearning?.snapshot(),
+  isRuntimeReady: runtimeOnboarding.isReady,
+  onNavigationChange: () => workspaceRoutes?.sync(),
+  state,
+  selection: runtimeSelection,
+  onConfigurationApplied: loadModels,
   dom,
   runtimeClient,
   selectedEnvironmentId,
@@ -625,7 +660,9 @@ function renderSessions() {
 }
 
 function renderMessages() {
+  notifications?.presenceChanged();
   conversationView.render();
+  workspaceRoutes?.sync();
 }
 
 function scheduleThinkingRender() {
@@ -677,7 +714,11 @@ function rejectPendingSteers(reason) {
 }
 
 function handleRealtimeMessage(message) {
-  realtimeEvents.handle(message);
+  dashboardFeature?.handleRealtime(message);
+  schedulesFeature?.handleRealtime(message);
+  passiveLearning?.handleRealtime(message);
+  notifications?.handleRealtime(message);
+  if (!isWorkspaceChange(message)) realtimeEvents.handle(message);
 }
 
 function sendRealtime(payload) {
@@ -700,18 +741,6 @@ async function restoreLastSession() {
   return conversationSession.restoreLastSession();
 }
 
-async function drainQueuedComposerMessage({
-  environmentId,
-  sessionId,
-  terminalRequestId,
-}) {
-  await composerQueueController.drain({
-    environmentId,
-    sessionId,
-    terminalRequestId,
-  });
-}
-
 async function loadRuntimeStatus() {
   await operationsController.loadRuntimeStatus();
 }
@@ -724,41 +753,38 @@ async function loadSystemHealth() {
   await operationsController.loadSystemHealth();
 }
 
-function bindEvents() {
-  appEventBindings.bind();
-  document.addEventListener(
-    "visibilitychange",
-    conversationSession.markCurrentSessionReadSoon,
-  );
-  dom.environmentSelect.addEventListener("change", () => {
-    homeComposer.environmentChanged();
-    dashboardFeature.environmentChanged();
-  });
-}
-
 function suspendRecoveredComposerReleaseForNavigation() {
   return composerQueueController.suspendRecoveryForNavigation();
 }
 
-void bootstrapWebApp({
+void startWebApp({
   state,
   dom,
   preferences,
   shell,
   homeComposer,
   dashboard: dashboardFeature,
+  learning: passiveLearning,
+  notifications,
   schedules: schedulesFeature,
+  projects: projectsFeature,
   selection: runtimeSelection,
   client: runtimeClient,
   bindables: [
+    notifications,
     sessionActionsMenu,
+    projectsFeature,
     conversationView,
     configWorkspace,
     composerActions,
     modelSelector,
     runtimeOnboarding,
   ],
-  bindEvents,
+  bindEvents: () => bindWebAppWorkspaceLifecycle({
+    appEventBindings, dom, runtimeSetupGuide, reloadModels: loadModels,
+    conversationSession, homeComposer, dashboardFeature, passiveLearning, notifications,
+    operations: operationsController,
+  }),
   renderComposer: () => {
     resizeComposerInput();
     updateComposerSendState();
@@ -768,9 +794,6 @@ void bootstrapWebApp({
   configuration: configWorkspace,
   realtime: realtimeTransport,
   restoreLastSession,
-}).catch((error) => {
-  setConnectionLabel(
-    error instanceof Error ? error.message : String(error),
-    true,
-  );
+  navigation: { bindings: appEventBindings, conversation: conversationSession },
+  onNavigationReady: (routes) => (workspaceRoutes = routes),
 });

package/dist/src/web-ui/app/components/composer-actions.d.ts

@@ -5,6 +5,7 @@ export declare function createComposerActions(options: {
     composerForm: HTMLFormElement;
     composerSubmitControl: HTMLElement;
     sendButton: HTMLButtonElement;
+    stopButton?: HTMLButtonElement;
     sendButtonLabel: HTMLElement;
     sendNextMenuButton: HTMLButtonElement;
     sendNextMenu: HTMLElement;
@@ -18,9 +19,12 @@ export declare function createComposerActions(options: {
   primaryAction(): ComposerAction;
   render(options: {
     activeRequestId: unknown;
+    waitingRequestId?: unknown;
     attachmentCount?: number;
     busy?: boolean;
     disabled?: boolean;
     queuedCount?: number;
+    stopping?: boolean;
+    onStop?: () => void;
   }): void;
 }>;

package/dist/src/web-ui/app/components/composer-actions.js

@@ -8,6 +8,7 @@ export function createComposerActions({
   let menuOpen = false;
   let primaryAction = "send";
   let splitAvailable = false;
+  let stopCurrent = () => {};
 
   function closeMenu({ restoreFocus = false } = {}) {
     if (!menuOpen) return false;
@@ -29,12 +30,28 @@ export function createComposerActions({
 
   function render({
     activeRequestId,
+    waitingRequestId,
     attachmentCount = 0,
     busy = false,
     disabled = false,
     queuedCount = 0,
+    stopping = false,
+    onStop = () => {},
   }) {
     const requestActive = Boolean(String(activeRequestId || "").trim());
+    stopCurrent = onStop;
+    if (dom.stopButton) {
+      const stoppable = requestActive || Boolean(waitingRequestId);
+      dom.stopButton.hidden = !stoppable;
+      dom.stopButton.disabled = !stoppable || stopping;
+      dom.stopButton.title = stopping
+        ? "Stopping…"
+        : waitingRequestId
+          ? "Cancel waiting request"
+          : "Stop response";
+      dom.stopButton.setAttribute("aria-label", dom.stopButton.title);
+      dom.stopButton.setAttribute("aria-busy", String(stopping));
+    }
     const hasAttachments = Number(attachmentCount) > 0;
     primaryAction = resolveComposerPrimaryAction(
       activeRequestId,
@@ -80,6 +97,9 @@ export function createComposerActions({
   }
 
   function bind() {
+    dom.stopButton?.addEventListener("click", () => {
+      if (!dom.stopButton.disabled) stopCurrent();
+    });
     dom.sendNextMenuButton.addEventListener("click", () => {
       if (!splitAvailable || dom.sendNextMenuButton.disabled) return;
       menuOpen = !menuOpen;

package/dist/src/web-ui/app/components/config-workspace/calibration-disclosure.js

@@ -0,0 +1,39 @@
+function calibrationExpansionTarget(state, details) {
+  const sectionKey = details?.dataset?.calibrationSectionKey;
+  if (sectionKey)
+    return { key: sectionKey, expanded: state.expandedCalibrationSections };
+  const profileKey = details?.dataset?.calibrationKey;
+  if (profileKey)
+    return { key: profileKey, expanded: state.expandedCalibrationKeys };
+  return null;
+}
+
+export function rememberCalibrationDisclosure(state, details) {
+  const target = calibrationExpansionTarget(state, details);
+  if (!target) return;
+  if (details.open) {
+    target.expanded.add(target.key);
+    return;
+  }
+  target.expanded.delete(target.key);
+}
+
+export function createConfigCalibrationDisclosure({ state, root }) {
+  let active = false;
+
+  function setActive(nextActive) {
+    const enteringConfig = nextActive && !active;
+    active = nextActive;
+    if (!enteringConfig) return;
+
+    state.expandedCalibrationKeys.clear();
+    state.expandedCalibrationSections.clear();
+    for (const details of root.querySelectorAll(
+      "details[data-calibration-key], details[data-calibration-section-key]",
+    )) {
+      details.open = false;
+    }
+  }
+
+  return { setActive };
+}

package/dist/src/web-ui/app/components/config-workspace/config-model.js

@@ -1,6 +1,14 @@
+import {
+  malformedConfigRaw,
+  configRequiresRawRepair,
+} from "./raw-config-repair.js";
 import { textOf } from "../../lib/text-format.js";
 
-export const CONFIG_CATEGORIES = ["memory", "pipeline", "models", "advanced"];
+export const CONFIG_CATEGORIES = [
+  "models",
+  "plugins",
+  "operations",
+];
 
 const DEFAULT_MODEL_EXECUTION_POLICY = "supervisor-worker-v1";
 
@@ -120,12 +128,14 @@ export function createConfigWorkspaceModel() {
     configDashboard: null,
     baselinesByKey: new Map(),
     rawDraftsByKey: new Map(),
+    appliedJsonRepairKeys: new Set(),
     savingKeys: new Set(),
     savedKeys: new Set(),
     expandedCalibrationKeys: new Set(),
+    expandedCalibrationSections: new Set(),
     selectedConfigModelId: "",
     selectedRawConfigKey: "",
-    activeCategory: "memory",
+    activeCategory: "models",
     rawPanelOpen: false,
     loadGeneration: 0,
     loading: false,
@@ -165,11 +175,15 @@ export function createConfigWorkspaceModel() {
   function captureBaselines() {
     state.baselinesByKey.clear();
     state.rawDraftsByKey.clear();
+    state.appliedJsonRepairKeys.clear();
     state.savedKeys.clear();
     for (const file of configFileEntries()) {
       const key = configFileKey(file);
       state.baselinesByKey.set(key, cloneConfig(file.config));
-      state.rawDraftsByKey.set(key, formattedConfig(file.config));
+      state.rawDraftsByKey.set(
+        key,
+        malformedConfigRaw(file) ?? formattedConfig(file.config),
+      );
     }
   }
 
@@ -178,6 +192,7 @@ export function createConfigWorkspaceModel() {
   }
 
   function isFileDirty(file) {
+    if (state.appliedJsonRepairKeys.has(configFileKey(file))) return true;
     const baseline = baselineFor(file);
     return baseline ? !configValuesEqual(file.config, baseline) : false;
   }
@@ -186,10 +201,13 @@ export function createConfigWorkspaceModel() {
     const key = configFileKey(file);
     return state.rawDraftsByKey.has(key)
       ? state.rawDraftsByKey.get(key)
-      : formattedConfig(file.config);
+      : (malformedConfigRaw(file) ?? formattedConfig(file.config));
   }
 
   function hasRawDraftChanges(file) {
+    const appliedRepair = state.appliedJsonRepairKeys.has(configFileKey(file));
+    if (configRequiresRawRepair(file, appliedRepair))
+      return rawDraftFor(file) !== malformedConfigRaw(file);
     return rawConfigDraftHasChanges(rawDraftFor(file), file.config);
   }