@grifhinz/logics-manager 2.2.0 → 2.3.1

package/clients/shared-web/media/mainInteractionHandlers.js

@@ -0,0 +1,324 @@
+(() => {
+  window.createCdxLogicsMainInteractionHandlers = function createCdxLogicsMainInteractionHandlers(options) {
+    const { core, hostApi, layoutController, stackedQuery, compactListQuery, state } = options;
+
+    const render = core && typeof core.render === "function" ? () => core.render() : () => undefined;
+    const persistState = core && typeof core.persistState === "function" ? () => core.persistState() : () => undefined;
+    const captureScrollState =
+      core && typeof core.captureScrollState === "function" ? () => core.captureScrollState() : () => undefined;
+    const schedulePersistState =
+      core && typeof core.schedulePersistState === "function"
+        ? () => core.schedulePersistState()
+        : () => undefined;
+    const resetPersistedUiState =
+      core && typeof core.resetPersistedUiState === "function"
+        ? () => core.resetPersistedUiState()
+        : () => undefined;
+    const setFilterPanelOpen =
+      core && typeof core.setFilterPanelOpen === "function" ? (isOpen) => core.setFilterPanelOpen(isOpen) : () => undefined;
+    const setToolsPanelOpen =
+      core && typeof core.setToolsPanelOpen === "function"
+        ? (viewNameOrOpen, maybeOpen) => {
+            if (typeof maybeOpen === "boolean") {
+              return core.setToolsPanelOpen(viewNameOrOpen, maybeOpen);
+            }
+            return core.setToolsPanelOpen(undefined, Boolean(viewNameOrOpen));
+          }
+        : () => undefined;
+    const restoreDefaultFilters =
+      core && typeof core.restoreDefaultFilters === "function" ? () => core.restoreDefaultFilters() : () => undefined;
+    const openSelectedItem =
+      core && typeof core.openSelectedItem === "function" ? (mode) => core.openSelectedItem(mode) : () => undefined;
+    const handleChangeProjectRoot =
+      core && typeof core.handleChangeProjectRoot === "function"
+        ? () => core.handleChangeProjectRoot()
+        : async () => undefined;
+    const handleResetProjectRoot =
+      core && typeof core.handleResetProjectRoot === "function"
+        ? () => core.handleResetProjectRoot()
+        : () => undefined;
+    const handleBootstrapLogics =
+      core && typeof core.handleBootstrapLogics === "function" ? () => core.handleBootstrapLogics() : () => undefined;
+    const handleAbout = core && typeof core.handleAbout === "function" ? () => core.handleAbout() : () => undefined;
+    const handleHostMessage =
+      core && typeof core.handleHostMessage === "function" ? (event) => core.handleHostMessage(event) : () => undefined;
+    const renderBoardErrorState =
+      core && typeof core.renderBoardErrorState === "function"
+        ? (message) => core.renderBoardErrorState(message)
+        : () => undefined;
+    const handleDocumentClick =
+      core && typeof core.handleDocumentClick === "function"
+        ? (event) => core.handleDocumentClick(event)
+        : () => undefined;
+    const handleDocumentKeydown =
+      core && typeof core.handleDocumentKeydown === "function"
+        ? (event) => core.handleDocumentKeydown(event)
+        : () => undefined;
+    const handleSplitterKeydown =
+      core && typeof core.handleSplitterKeydown === "function"
+        ? (event) => core.handleSplitterKeydown(event)
+        : () => undefined;
+    const handleResponsiveLayoutChange =
+      core && typeof core.handleResponsiveLayoutChange === "function"
+        ? () => core.handleResponsiveLayoutChange()
+        : () => undefined;
+
+    return {
+      onNewRequest() {
+        hostApi.newRequest();
+        setToolsPanelOpen(false);
+      },
+      onAbout() {
+        handleAbout();
+        setToolsPanelOpen(false);
+      },
+      onActivityToggle() {
+        const nextOpen = !state.activityPanelOpen;
+        const shouldCollapseForStackedLayout =
+          nextOpen &&
+          ((stackedQuery && stackedQuery.matches) ||
+            (layoutController &&
+              typeof layoutController.isStackedLayout === "function" &&
+              layoutController.isStackedLayout()));
+        if (shouldCollapseForStackedLayout) {
+          state.uiState.detailsCollapsed = true;
+        }
+        state.activityPanelOpen = !state.activityPanelOpen;
+        persistState();
+        render();
+      },
+      onBoardScroll() {
+        captureScrollState();
+        schedulePersistState();
+      },
+      onBootstrapLogics() {
+        handleBootstrapLogics();
+        setToolsPanelOpen(false);
+      },
+      onUpdateLogicsKit() {
+        hostApi.updateLogicsKit();
+        setToolsPanelOpen(false);
+      },
+      onRepairLogicsKit() {
+        hostApi.repairLogicsKit();
+        setToolsPanelOpen(false);
+      },
+      onCheckEnvironment() {
+        hostApi.checkEnvironment();
+        setToolsPanelOpen(false);
+      },
+      onCheckHybridRuntime() {
+        hostApi.checkHybridRuntime();
+        setToolsPanelOpen(false);
+      },
+      onOpenHybridInsights() {
+        hostApi.openHybridInsights();
+        setToolsPanelOpen(false);
+      },
+      onOpenLogicsInsights() {
+        hostApi.openLogicsInsights();
+        setToolsPanelOpen(false);
+      },
+      onOpenOnboarding() {
+        hostApi.openOnboarding();
+        setToolsPanelOpen(false);
+      },
+      onAssistCommitAll() {
+        hostApi.assistCommitAll();
+        setToolsPanelOpen(false);
+      },
+      onAssistNextStep() {
+        hostApi.assistNextStep();
+        setToolsPanelOpen(false);
+      },
+      onAssistTriage() {
+        hostApi.assistTriage(state.selectedId || undefined);
+        setToolsPanelOpen(false);
+      },
+      onAssistDiffRisk() {
+        hostApi.assistDiffRisk();
+        setToolsPanelOpen(false);
+      },
+      onAssistSummarizeChangelog() {
+        hostApi.assistSummarizeChangelog();
+        setToolsPanelOpen(false);
+      },
+      onAssistPrepareRelease() {
+        hostApi.assistPrepareRelease();
+        setToolsPanelOpen(false);
+      },
+      onAssistPublishRelease() {
+        hostApi.assistPublishRelease();
+        setToolsPanelOpen(false);
+      },
+      onAssistSummarizeValidation() {
+        hostApi.assistSummarizeValidation();
+        setToolsPanelOpen(false);
+      },
+      onAssistValidationChecklist() {
+        hostApi.assistValidationChecklist();
+        setToolsPanelOpen(false);
+      },
+      onAssistDocConsistency() {
+        hostApi.assistDocConsistency();
+        setToolsPanelOpen(false);
+      },
+      onChangeProjectRoot() {
+        return handleChangeProjectRoot();
+      },
+      onCreateCompanionDoc(action) {
+        if (action === "new-request-guided") {
+          hostApi.newGuidedRequest();
+        } else {
+          hostApi.createCompanionDoc(state.selectedId || undefined);
+        }
+        setToolsPanelOpen(false);
+      },
+      onDetailsScroll() {
+        captureScrollState();
+        schedulePersistState();
+      },
+      onDetailsToggle() {
+        state.uiState.detailsCollapsed = !state.uiState.detailsCollapsed;
+        persistState();
+        render();
+      },
+      onDocumentClick(event) {
+        handleDocumentClick(event);
+      },
+      onDocumentKeydown(event) {
+        handleDocumentKeydown(event);
+      },
+      onFilterPanelToggle(event) {
+        event.stopPropagation();
+        if (state.toolsPanelOpen) {
+          setToolsPanelOpen(false);
+        }
+        setFilterPanelOpen(!state.secondaryToolbarOpen);
+      },
+      onFilterReset() {
+        restoreDefaultFilters();
+        persistState();
+        render();
+      },
+      onGroupChange(event) {
+        state.groupMode = event.target ? String(event.target.value || "stage") : "stage";
+        persistState();
+        render();
+      },
+      onHelpDismiss() {
+        state.helpDismissed = true;
+        persistState();
+        render();
+      },
+      onHideCompleteChange(event) {
+        state.hideCompleted = Boolean(event.target && event.target.checked);
+        persistState();
+        render();
+      },
+      onHideEmptyColumnsChange(event) {
+        state.hideEmptyColumns = Boolean(event.target && event.target.checked);
+        persistState();
+        render();
+      },
+      onHideProcessedRequestsChange(event) {
+        state.hideProcessedRequests = Boolean(event.target && event.target.checked);
+        persistState();
+        render();
+      },
+      onHideSpecChange(event) {
+        state.hideSpec = Boolean(event.target && event.target.checked);
+        persistState();
+        render();
+      },
+      onMarkDone() {
+        const item = state.items.find((entry) => entry.id === state.selectedId);
+        if (!item) {
+          return;
+        }
+        hostApi.markDone(item);
+      },
+      onMarkObsolete() {
+        const item = state.items.find((entry) => entry.id === state.selectedId);
+        if (!item) {
+          return;
+        }
+        hostApi.markObsolete(item);
+      },
+      onChangeStatus() {
+        const item = state.items.find((entry) => entry.id === state.selectedId);
+        if (!item) {
+          return;
+        }
+        hostApi.changeStatus(item);
+      },
+      onOpenSelectedItem() {
+        openSelectedItem("open");
+      },
+      onPromoteSelectedItem() {
+        if (!state.selectedId) {
+          return;
+        }
+        hostApi.promote(state.selectedId);
+      },
+      onReadSelectedItem() {
+        openSelectedItem("read");
+      },
+      onResetProjectRoot() {
+        handleResetProjectRoot();
+        setToolsPanelOpen(false);
+      },
+      onSearchInput(event) {
+        state.searchQuery = event.target ? String(event.target.value || "") : "";
+        persistState();
+        render();
+      },
+      onSelectAgent() {
+        hostApi.selectAgent();
+        setToolsPanelOpen(false);
+      },
+      onShowCompanionDocsChange(event) {
+        state.showCompanionDocs = Boolean(event.target && event.target.checked);
+        persistState();
+        render();
+      },
+      onSortChange(event) {
+        state.sortMode = event.target ? String(event.target.value || "default") : "default";
+        persistState();
+        render();
+      },
+      onSplitterKeydown(event) {
+        handleSplitterKeydown(event);
+      },
+      onToggleAttention() {
+        state.attentionOnly = !state.attentionOnly;
+        persistState();
+        render();
+      },
+      onToggleViewMode() {
+        if (compactListQuery && compactListQuery.matches) {
+          return;
+        }
+        state.uiState.viewMode = state.uiState.viewMode === "list" ? "board" : "list";
+        persistState();
+        render();
+      },
+      onToolsPanelToggle(viewName, event) {
+        const activeView = typeof viewName === "string" && viewName ? viewName : "workflow";
+        const nativeEvent = event && typeof event === "object" && "stopPropagation" in event ? event : null;
+        if (nativeEvent && typeof nativeEvent.stopPropagation === "function") {
+          nativeEvent.stopPropagation();
+        }
+        const shouldOpen = !state.toolsPanelOpen || state.toolsPanelView !== activeView;
+        state.toolsPanelView = shouldOpen ? activeView : state.toolsPanelView;
+        setToolsPanelOpen(activeView, shouldOpen);
+      },
+      onWindowMessage(event) {
+        handleHostMessage(event);
+      },
+      onWindowResize() {
+        handleResponsiveLayoutChange();
+      }
+    };
+  };
+})();

package/clients/shared-web/media/mainInteractions.js

@@ -0,0 +1,378 @@
+(() => {
+  window.createCdxLogicsMainInteractions = function createCdxLogicsMainInteractions(options) {
+    const {
+      activityToggle,
+      attentionToggle,
+      headerLogicsInsightsButton,
+      board,
+      assistCommitAllButton,
+      assistNextStepButton,
+      assistTriageButton,
+      assistDiffRiskButton,
+      assistSummarizeChangelogButton,
+      assistPrepareReleaseButton,
+      assistPublishReleaseButton,
+      assistSummarizeValidationButton,
+      assistValidationChecklistButton,
+      assistDocConsistencyButton,
+      bootstrapLogicsButton,
+      checkHybridRuntimeButton,
+      checkEnvironmentButton,
+      openHybridInsightsButton,
+      openLogicsInsightsButton,
+      openOnboardingButton,
+      changeProjectRootButton,
+      compactListQuery,
+      createCompanionDocToolButton,
+      detailsBody,
+      detailsToggle,
+      filterPanel,
+      filterResetButton,
+      filterToggle,
+      groupBySelect,
+      helpBannerDismiss,
+      hideCompleteToggle,
+      hideEmptyColumnsToggle,
+      hideProcessedRequestsToggle,
+      hideSpecToggle,
+      layoutController,
+      repairLogicsKitButton,
+      mainPane,
+      markDoneButton,
+      markObsoleteButton,
+      changeStatusButton,
+      newRequestToolButton,
+      onNewRequest,
+      onAbout,
+      onActivityToggle,
+      onBoardScroll,
+      onBootstrapLogics,
+      onCheckHybridRuntime,
+      onCheckEnvironment,
+      onOpenHybridInsights,
+      onOpenLogicsInsights,
+      onOpenOnboarding,
+      onChangeProjectRoot,
+      onAssistCommitAll,
+      onAssistNextStep,
+      onAssistTriage,
+      onAssistDiffRisk,
+      onAssistSummarizeChangelog,
+      onAssistPrepareRelease,
+      onAssistPublishRelease,
+      onAssistSummarizeValidation,
+      onAssistValidationChecklist,
+      onAssistDocConsistency,
+      onCreateCompanionDoc,
+      onDetailsScroll,
+      onDetailsToggle,
+      onDocumentClick,
+      onDocumentKeydown,
+      onFilterPanelToggle,
+      onFilterReset,
+      onGroupChange,
+      onHelpDismiss,
+      onHideCompleteChange,
+      onHideEmptyColumnsChange,
+      onHideProcessedRequestsChange,
+      onHideSpecChange,
+      onMarkDone,
+      onMarkObsolete,
+      onChangeStatus,
+      onOpenSelectedItem,
+      onPromoteSelectedItem,
+      onReadSelectedItem,
+      onResetProjectRoot,
+      onSearchInput,
+      onSelectAgent,
+      onShowCompanionDocsChange,
+      onSortChange,
+      onSplitterKeydown,
+      onToggleViewMode,
+      onToggleAttention,
+      onToolsPanelToggle,
+      onUpdateLogicsKit,
+      onRepairLogicsKit,
+      onWindowMessage,
+      onWindowResize,
+      openButton,
+      promoteButton,
+      readButton,
+      getToolsPanelView,
+      resetProjectRootButton,
+      searchInput,
+      selectAgentButton,
+      setControlDescription,
+      showCompanionDocsToggle,
+      sortBySelect,
+      splitter,
+      stackedQuery,
+      toolsPanel,
+      toolsToggle,
+      updateLogicsKitButton,
+      viewModeToggleButton,
+      aboutButton
+    } = options;
+
+    function attachMediaQueryListener(query, callback) {
+      if (!query || typeof callback !== "function") {
+        return;
+      }
+      if (typeof query.addEventListener === "function") {
+        query.addEventListener("change", callback);
+        return;
+      }
+      if (typeof query.addListener === "function") {
+        query.addListener(callback);
+      }
+    }
+
+    function attach() {
+      if (headerLogicsInsightsButton) {
+        headerLogicsInsightsButton.addEventListener("click", () => onOpenLogicsInsights());
+      }
+      if (viewModeToggleButton) {
+        viewModeToggleButton.addEventListener("click", () => onToggleViewMode());
+      }
+      if (bootstrapLogicsButton) {
+        bootstrapLogicsButton.addEventListener("click", () => onBootstrapLogics());
+      }
+      if (updateLogicsKitButton) {
+        updateLogicsKitButton.addEventListener("click", () => onUpdateLogicsKit());
+      }
+      if (repairLogicsKitButton) {
+        repairLogicsKitButton.addEventListener("click", () => onRepairLogicsKit());
+      }
+      if (checkEnvironmentButton) {
+        checkEnvironmentButton.addEventListener("click", () => onCheckEnvironment());
+      }
+      if (checkHybridRuntimeButton) {
+        checkHybridRuntimeButton.addEventListener("click", () => onCheckHybridRuntime());
+      }
+      if (openHybridInsightsButton) {
+        openHybridInsightsButton.addEventListener("click", () => onOpenHybridInsights());
+      }
+      if (openLogicsInsightsButton) {
+        openLogicsInsightsButton.addEventListener("click", () => onOpenLogicsInsights());
+      }
+      if (openOnboardingButton) {
+        openOnboardingButton.addEventListener("click", () => onOpenOnboarding());
+      }
+      if (assistCommitAllButton) {
+        assistCommitAllButton.addEventListener("click", () => onAssistCommitAll());
+      }
+      if (assistNextStepButton) {
+        assistNextStepButton.addEventListener("click", () => onAssistNextStep());
+      }
+      if (assistTriageButton) {
+        assistTriageButton.addEventListener("click", () => onAssistTriage());
+      }
+      if (assistDiffRiskButton) {
+        assistDiffRiskButton.addEventListener("click", () => onAssistDiffRisk());
+      }
+      if (assistSummarizeChangelogButton) {
+        assistSummarizeChangelogButton.addEventListener("click", () => onAssistSummarizeChangelog());
+      }
+      if (assistPrepareReleaseButton) {
+        assistPrepareReleaseButton.addEventListener("click", () => onAssistPrepareRelease());
+      }
+      if (assistPublishReleaseButton) {
+        assistPublishReleaseButton.addEventListener("click", () => onAssistPublishRelease());
+      }
+      if (assistSummarizeValidationButton) {
+        assistSummarizeValidationButton.addEventListener("click", () => onAssistSummarizeValidation());
+      }
+      if (assistValidationChecklistButton) {
+        assistValidationChecklistButton.addEventListener("click", () => onAssistValidationChecklist());
+      }
+      if (assistDocConsistencyButton) {
+        assistDocConsistencyButton.addEventListener("click", () => onAssistDocConsistency());
+      }
+      if (newRequestToolButton) {
+        newRequestToolButton.addEventListener("click", () => onNewRequest());
+      }
+      if (createCompanionDocToolButton) {
+        createCompanionDocToolButton.addEventListener("click", () => onCreateCompanionDoc("create-companion-doc"));
+      }
+      if (selectAgentButton) {
+        selectAgentButton.addEventListener("click", () => onSelectAgent());
+      }
+      if (changeProjectRootButton) {
+        changeProjectRootButton.addEventListener("click", () => onChangeProjectRoot());
+      }
+      if (resetProjectRootButton) {
+        resetProjectRootButton.addEventListener("click", () => onResetProjectRoot());
+      }
+      if (aboutButton) {
+        aboutButton.addEventListener("click", () => onAbout());
+      }
+      if (filterToggle) {
+        filterToggle.addEventListener("click", (event) => onFilterPanelToggle(event));
+      }
+      if (toolsToggle) {
+        toolsToggle.addEventListener(
+          "click",
+          (event) => onToolsPanelToggle(typeof getToolsPanelView === "function" ? getToolsPanelView() || "workflow" : "workflow", event)
+        );
+      }
+      if (hideCompleteToggle) {
+        hideCompleteToggle.addEventListener("change", (event) => onHideCompleteChange(event));
+      }
+      if (hideProcessedRequestsToggle) {
+        hideProcessedRequestsToggle.addEventListener("change", (event) => onHideProcessedRequestsChange(event));
+      }
+      if (hideSpecToggle) {
+        hideSpecToggle.addEventListener("change", (event) => onHideSpecChange(event));
+      }
+      if (showCompanionDocsToggle) {
+        showCompanionDocsToggle.addEventListener("change", (event) => onShowCompanionDocsChange(event));
+      }
+      if (hideEmptyColumnsToggle) {
+        hideEmptyColumnsToggle.addEventListener("change", (event) => onHideEmptyColumnsChange(event));
+      }
+      if (filterResetButton) {
+        filterResetButton.addEventListener("click", () => onFilterReset());
+      }
+      if (searchInput) {
+        searchInput.addEventListener("input", (event) => onSearchInput(event));
+      }
+      if (groupBySelect) {
+        groupBySelect.addEventListener("change", (event) => onGroupChange(event));
+      }
+      if (sortBySelect) {
+        sortBySelect.addEventListener("change", (event) => onSortChange(event));
+      }
+      if (attentionToggle) {
+        attentionToggle.addEventListener("click", () => onToggleAttention());
+      }
+      if (activityToggle) {
+        activityToggle.addEventListener("click", () => onActivityToggle());
+      }
+      if (helpBannerDismiss) {
+        helpBannerDismiss.addEventListener("click", () => onHelpDismiss());
+      }
+      if (board) {
+        board.addEventListener("scroll", () => onBoardScroll());
+      }
+      if (detailsBody) {
+        detailsBody.addEventListener("scroll", () => onDetailsScroll());
+      }
+      if (detailsToggle) {
+        detailsToggle.addEventListener("click", () => onDetailsToggle());
+      }
+      if (openButton) {
+        openButton.addEventListener("click", () => onOpenSelectedItem());
+      }
+      if (readButton) {
+        readButton.addEventListener("click", () => onReadSelectedItem());
+      }
+      if (promoteButton) {
+        promoteButton.addEventListener("click", () => onPromoteSelectedItem());
+      }
+      if (markDoneButton) {
+        markDoneButton.addEventListener("click", () => onMarkDone());
+      }
+      if (markObsoleteButton) {
+        markObsoleteButton.addEventListener("click", () => onMarkObsolete());
+      }
+      if (changeStatusButton) {
+        changeStatusButton.addEventListener("click", () => onChangeStatus());
+      }
+      if (toolsPanel) {
+        const toolsPanelCloseButton = toolsPanel.querySelector("[data-tools-panel-close]");
+        if (toolsPanelCloseButton instanceof HTMLElement) {
+          toolsPanelCloseButton.addEventListener("click", () => setToolsPanelOpen(false));
+        }
+        Array.from(toolsPanel.querySelectorAll("[data-tools-view-switch]")).forEach((button) => {
+          if (!(button instanceof HTMLElement)) {
+            return;
+          }
+          const viewName = button.getAttribute("data-tools-view-switch") || "workflow";
+          button.addEventListener("click", (event) => onToolsPanelToggle(viewName, event));
+        });
+      }
+
+      window.addEventListener("message", (event) => onWindowMessage(event));
+      document.addEventListener("click", (event) => onDocumentClick(event));
+      document.addEventListener("keydown", (event) => onDocumentKeydown(event));
+
+      if (splitter) {
+        splitter.addEventListener("pointerdown", (event) => {
+          if (layoutController && typeof layoutController.startSplitDrag === "function") {
+            layoutController.startSplitDrag(event);
+          }
+        });
+        splitter.addEventListener("pointermove", (event) => {
+          if (layoutController && typeof layoutController.updateSplitDrag === "function") {
+            layoutController.updateSplitDrag(event);
+          }
+        });
+        splitter.addEventListener("pointerup", (event) => {
+          if (layoutController && typeof layoutController.endSplitDrag === "function") {
+            layoutController.endSplitDrag(event);
+          }
+        });
+        splitter.addEventListener("pointercancel", (event) => {
+          if (layoutController && typeof layoutController.endSplitDrag === "function") {
+            layoutController.endSplitDrag(event);
+          }
+        });
+        splitter.addEventListener("keydown", (event) => onSplitterKeydown(event));
+      }
+
+      attachMediaQueryListener(stackedQuery, onWindowResize);
+      attachMediaQueryListener(compactListQuery, onWindowResize);
+      window.addEventListener("resize", () => onWindowResize());
+
+      setControlDescription(filterToggle, "Show view controls");
+      setControlDescription(toolsToggle, "Open tools menu");
+      setControlDescription(viewModeToggleButton, "Switch display mode");
+      setControlDescription(selectAgentButton, "Select active agent");
+      setControlDescription(newRequestToolButton, "Create a new request document");
+      setControlDescription(bootstrapLogicsButton, "Bootstrap Logics");
+      setControlDescription(checkEnvironmentButton, "Review environment health and recommended fixes");
+      setControlDescription(checkHybridRuntimeButton, "Check hybrid assist runtime health");
+      setControlDescription(openHybridInsightsButton, "Open the hybrid assist ROI insights panel");
+      setControlDescription(openLogicsInsightsButton, "Open repository-level Logics stats and relationship signals");
+      setControlDescription(assistCommitAllButton, "Suggest or execute a bounded commit plan");
+      setControlDescription(assistNextStepButton, "Suggest the next bounded workflow step");
+      setControlDescription(assistTriageButton, "Classify a workflow doc through the shared runtime");
+      setControlDescription(assistDiffRiskButton, "Assess the current diff risk through the shared runtime");
+      setControlDescription(assistSummarizeChangelogButton, "Generate bounded changelog entries through the shared runtime");
+      setControlDescription(assistPrepareReleaseButton, "Generate changelog via AI if missing, update README badge, and commit prep changes");
+      setControlDescription(assistPublishReleaseButton, "Create the release tag, push, and publish the GitHub release");
+      setControlDescription(assistSummarizeValidationButton, "Summarize validation status");
+      setControlDescription(assistValidationChecklistButton, "Build a bounded validation checklist through the shared runtime");
+      setControlDescription(assistDocConsistencyButton, "Review workflow doc consistency through the shared runtime");
+      setControlDescription(changeProjectRootButton, "Change project root");
+      setControlDescription(resetProjectRootButton, "Use workspace root");
+      setControlDescription(repairLogicsKitButton, "Check current Logics runtime state and repair the shared kit publication or bridge files.");
+      setControlDescription(aboutButton, "About this extension");
+      setControlDescription(detailsToggle, detailsToggle?.getAttribute("aria-label") || "Collapse details");
+      setControlDescription(markDoneButton, "Mark selected item as done");
+      setControlDescription(markObsoleteButton, "Mark selected item as obsolete");
+      setControlDescription(changeStatusButton, "Change selected item status");
+      setControlDescription(openButton, "Edit selected item");
+      setControlDescription(readButton, "Read selected item");
+      setControlDescription(promoteButton, "Promote selected item");
+      if (toolsPanel) {
+        toolsPanel.setAttribute("role", "menu");
+      }
+      if (filterPanel) {
+        filterPanel.setAttribute("role", "group");
+        filterPanel.setAttribute("aria-label", "View controls");
+      }
+      if (filterToggle && filterPanel && filterPanel.id) {
+        filterToggle.setAttribute("aria-controls", filterPanel.id);
+      }
+      if (toolsToggle && toolsPanel && toolsPanel.id) {
+        toolsToggle.setAttribute("aria-controls", toolsPanel.id);
+      }
+      if (mainPane) {
+        mainPane.classList.toggle("layout__main--activity", false);
+      }
+    }
+
+    return { attach };
+  };
+})();