@iblai/iblai-js 2.4.4 → 2.5.0

package/dist/playwright/index.cjs

@@ -2329,8 +2329,9 @@ async function verifySkillsTabVisible(page) {
     logger.info('Skills section is visible with Agent/Available sub-tabs');
 }
 /**
- * Switch to the "Agent Skills" sub-tab (the agent's own skills, with enable
- * toggles; the default sub-tab) and wait for its panel to render.
+ * Switch to the "Agent Skills" sub-tab (the agent's assigned skills with
+ * enable toggles, paged server-side 10 per page; the default sub-tab) and
+ * wait for its panel to render.
  */
 async function switchToAgentSkillsSubTab(page) {
     await page.getByTestId('agent-skills-tab-agent').click();
@@ -2416,8 +2417,8 @@ async function addSkillToAgent(page, skillName) {
     logger.info(`Added skill "${skillName}" to the agent`);
 }
 /**
- * Verify a catalog row shows the "Added" chip (already on the agent, or
- * shadowed by a same-slug private skill) and offers no Add button.
+ * Verify a catalog row shows the "Added" chip (the skill is assigned to the
+ * agent) and offers no Add button.
  */
 async function verifySkillAdded(page, skillName) {
     const row = availableSkillRow(page, skillName);
@@ -2426,8 +2427,10 @@ async function verifySkillAdded(page, skillName) {
     logger.info(`Skill "${skillName}" shows as Added`);
 }
 /**
- * Open the three-dots actions menu for a skill row. The menu content portals
- * to document.body, so the returned locator is page-level by design.
+ * Open the three-dots actions menu for a skill row on the active sub-tab.
+ * Agent-tab rows offer "Remove from Agent" only; catalog rows offer
+ * Edit/Delete (for editable skills). The menu content portals to
+ * document.body, so the returned locator is page-level by design.
  */
 async function openSkillActionsMenu(page, skillName) {
     const actionsButton = page.getByRole('button', { name: `${skillName} actions` });
@@ -2503,6 +2506,23 @@ async function toggleSkill(page, skillName) {
     await enableSkill(page, skillName);
     return true;
 }
+/**
+ * Set a skill's platform-wide enabled flag via its "Available Skills"
+ * catalog row Switch (skill-level PATCH — the agent-tab switches PATCH the
+ * assignment instead). No-op when already in the requested state; waits for
+ * the success toast otherwise. Read-only featured rows have no switch.
+ */
+async function setCatalogSkillEnabled(page, skillName, enabled) {
+    const switchEl = availableSkillRow(page, skillName).getByRole('switch');
+    await test$1.expect(switchEl).toBeVisible({ timeout: 10000 });
+    if ((await switchEl.isChecked()) === enabled) {
+        logger.info(`Catalog skill "${skillName}" already ${enabled ? 'enabled' : 'disabled'}`);
+        return;
+    }
+    await switchEl.click();
+    await test$1.expect(page.getByText(`${skillName} ${enabled ? 'enabled' : 'disabled'}`, { exact: false })).toBeVisible({ timeout: 10000 });
+    logger.info(`${enabled ? 'Enabled' : 'Disabled'} catalog skill "${skillName}"`);
+}
 /**
  * Open the "New Skill" dialog from the Skills section. Returns the dialog
  * locator — resolve every field from it (the dialog stacks over the
@@ -2573,7 +2593,9 @@ async function createSkill(page, values) {
     logger.info(`Created skill "${values.name}"`);
 }
 /**
- * Open the Edit Skill dialog for a row (lands on the General sub-tab).
+ * Open the Edit Skill dialog for a catalog row (lands on the General
+ * sub-tab). Skill edit/delete actions live on the "Available Skills"
+ * sub-tab — switch there first (`switchToAvailableSkillsSubTab`).
  * Returns the dialog locator — resolve fields and sub-tabs from it.
  */
 async function openEditSkillDialog(page, skillName) {
@@ -2583,7 +2605,8 @@ async function openEditSkillDialog(page, skillName) {
     return waitForDialogReady(page, dialog);
 }
 /**
- * Edit an existing platform-level skill (General sub-tab fields).
+ * Edit an existing platform-level skill (General sub-tab fields) from its
+ * catalog row — switch to the "Available Skills" sub-tab first.
  */
 async function editSkill(page, skillName, updates) {
     const dialog = await openEditSkillDialog(page, skillName);
@@ -2621,8 +2644,8 @@ async function editSkill(page, skillName, updates) {
     logger.info(`Edited skill "${skillName}"`);
 }
 /**
- * Delete a platform-level skill via its row menu, confirming the
- * "Delete Skill" dialog.
+ * Delete a platform-level skill via its catalog row menu (switch to the
+ * "Available Skills" sub-tab first), confirming the "Delete Skill" dialog.
  */
 async function deleteSkill(page, skillName) {
     const menu = await openSkillActionsMenu(page, skillName);
@@ -4359,19 +4382,19 @@ const GRADER_LABELS = {
         both: 'Overall + per Criterion',
     },
 };
-const UI_TIMEOUT = 10000;
-const MUTATION_TIMEOUT = 15000;
+const UI_TIMEOUT$1 = 10000;
+const MUTATION_TIMEOUT$1 = 15000;
 /**
  * The edit-agent dialog that hosts the settings tabs. Scoping through the
  * dialog first keeps every subsequent query away from same-named elements
  * elsewhere on the page (nested portals, background page content).
  */
-function editAgentDialog(page) {
+function editAgentDialog$1(page) {
     return page.getByRole('dialog').filter({ has: page.getByRole('tablist') });
 }
 /** The Grader tab's body, scoped through the edit-agent dialog. */
 function graderTabBody(page) {
-    return editAgentDialog(page).getByTestId('grader-tab-body');
+    return editAgentDialog$1(page).getByTestId('grader-tab-body');
 }
 /** The Rubric sub-tab's section within the tab body. */
 function criteriaSection(page) {
@@ -4388,7 +4411,7 @@ function criterionRow(page, name) {
  * edit-agent dialog (host didn't register it, or RBAC hid it).
  */
 async function isGraderTabVisible(page) {
-    const tab = editAgentDialog(page).getByRole('tab', {
+    const tab = editAgentDialog$1(page).getByRole('tab', {
         name: GRADER_LABELS.tabName,
         exact: true,
     });
@@ -4405,11 +4428,11 @@ async function isGraderTabVisible(page) {
  * open. Completion is gated on the tab body's testid, not on timing.
  */
 async function switchToGraderTab(page) {
-    const dialog = editAgentDialog(page);
+    const dialog = editAgentDialog$1(page);
     const tab = dialog.getByRole('tab', { name: GRADER_LABELS.tabName, exact: true });
-    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await tab.click();
-    await test$1.expect(graderTabBody(page)).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(graderTabBody(page)).toBeVisible({ timeout: UI_TIMEOUT$1 });
     logger.info('Switched to Grader tab');
 }
 /**
@@ -4419,7 +4442,7 @@ async function switchToGraderTab(page) {
 async function switchToGraderSubTab(page, subTab) {
     const body = graderTabBody(page);
     const trigger = body.getByTestId(`grader-sub-tab-${subTab}`);
-    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await trigger.click();
     const sectionTestId = {
         setup: 'grader-setup-section',
@@ -4427,13 +4450,13 @@ async function switchToGraderSubTab(page, subTab) {
         results: 'grader-results-section',
     }[subTab];
     const section = body.getByTestId(sectionTestId);
-    await test$1.expect(section).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(section).toBeVisible({ timeout: UI_TIMEOUT$1 });
     logger.info(`Switched to Grader ${subTab} sub-tab`);
 }
 /** Read the current on/off state of the Grading capability toggle. */
 async function isGradingEnabled(page) {
     const toggle = graderTabBody(page).getByTestId('grader-capability-toggle');
-    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT$1 });
     return (await toggle.getAttribute('aria-checked')) === 'true';
 }
 /**
@@ -4445,35 +4468,35 @@ async function isGradingEnabled(page) {
 async function setGradingEnabled(page, enabled) {
     const body = graderTabBody(page);
     const toggle = body.getByTestId('grader-capability-toggle');
-    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT$1 });
     if ((await toggle.getAttribute('aria-checked')) === String(enabled)) {
         logger.info(`Grading already ${enabled ? 'enabled' : 'disabled'} — no toggle needed`);
         return;
     }
-    await test$1.expect(toggle).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(toggle).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await toggle.click();
     const toastText = enabled ? GRADER_LABELS.toasts.toggleOn : GRADER_LABELS.toasts.toggleOff;
     // .first() is deliberate: rapid toggles can stack identical sonner toasts,
     // and any one of them proves the PATCH resolved.
-    await test$1.expect(page.getByText(toastText).first()).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(page.getByText(toastText).first()).toBeVisible({ timeout: MUTATION_TIMEOUT$1 });
     await test$1.expect(toggle).toHaveAttribute('aria-checked', String(enabled), {
-        timeout: MUTATION_TIMEOUT,
+        timeout: MUTATION_TIMEOUT$1,
     });
-    await test$1.expect(body.getByTestId('capability-gate-content')).toHaveAttribute('data-enabled', String(enabled), { timeout: UI_TIMEOUT });
+    await test$1.expect(body.getByTestId('capability-gate-content')).toHaveAttribute('data-enabled', String(enabled), { timeout: UI_TIMEOUT$1 });
     logger.info(`Grading ${enabled ? 'enabled' : 'disabled'}`);
 }
 /** Pick an option in one of the setup form's two Radix selects. */
-async function pickSelectOption(page, triggerTestId, optionLabel) {
+async function pickSelectOption$1(page, triggerTestId, optionLabel) {
     const trigger = graderTabBody(page).getByTestId(triggerTestId);
-    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await trigger.click();
     // Radix renders the listbox in a portal outside the dialog, so the
     // option is looked up by role at page level — the open listbox is the
     // only one in the document.
     const option = page.getByRole('option', { name: optionLabel, exact: true });
-    await test$1.expect(option).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(option).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await option.click();
-    await test$1.expect(option).toBeHidden({ timeout: UI_TIMEOUT });
+    await test$1.expect(option).toBeHidden({ timeout: UI_TIMEOUT$1 });
 }
 /**
  * Fill and persist the Grading setup form (switches to the setup sub-tab
@@ -4485,26 +4508,26 @@ async function saveGraderConfig(page, values) {
     await switchToGraderSubTab(page, 'setup');
     const body = graderTabBody(page);
     if (values.gradingMode) {
-        await pickSelectOption(page, 'grader-grading-mode-select', GRADER_LABELS.gradingModeOptions[values.gradingMode]);
+        await pickSelectOption$1(page, 'grader-grading-mode-select', GRADER_LABELS.gradingModeOptions[values.gradingMode]);
     }
     if (values.feedbackMode) {
-        await pickSelectOption(page, 'grader-feedback-mode-select', GRADER_LABELS.feedbackModeOptions[values.feedbackMode]);
+        await pickSelectOption$1(page, 'grader-feedback-mode-select', GRADER_LABELS.feedbackModeOptions[values.feedbackMode]);
     }
     if (values.instructions !== undefined) {
         const textarea = body.getByTestId('grader-instructions-textarea');
-        await test$1.expect(textarea).toBeVisible({ timeout: UI_TIMEOUT });
+        await test$1.expect(textarea).toBeVisible({ timeout: UI_TIMEOUT$1 });
         await textarea.fill(values.instructions);
     }
     const saveButton = body.getByTestId('grader-save-button');
-    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await saveButton.click();
-    await test$1.expect(saveButton).toBeDisabled({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(saveButton).toBeDisabled({ timeout: MUTATION_TIMEOUT$1 });
     logger.info('Saved grader configuration');
 }
 /** Fill the criterion modal's three fields and submit it. */
 async function submitCriterionModal(page, criterion) {
     const modal = page.getByTestId('grader-criterion-modal');
-    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await modal.getByLabel(GRADER_LABELS.modal.fields.name, { exact: true }).fill(criterion.name);
     await modal
         .getByLabel(GRADER_LABELS.modal.fields.criteria, { exact: true })
@@ -4513,21 +4536,21 @@ async function submitCriterionModal(page, criterion) {
         .getByLabel(GRADER_LABELS.modal.fields.points, { exact: true })
         .fill(String(criterion.points));
     const saveButton = modal.getByTestId('grader-criterion-modal-save');
-    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await saveButton.click();
     // The modal only closes itself after the mutation resolves.
-    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT$1 });
 }
 /** Open a rubric row's three-dots menu and click one of its actions. */
 async function clickRowMenuAction(page, name, action) {
     const trigger = criterionRow(page, name).getByRole('button', {
         name: GRADER_LABELS.menu.actionsAria(name),
     });
-    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await trigger.click();
     // The menu portals to the page root — the open menu is the only one.
     const item = page.getByRole('menuitem', { name: action, exact: true });
-    await test$1.expect(item).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(item).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await item.click();
 }
 /**
@@ -4539,10 +4562,10 @@ async function clickRowMenuAction(page, name, action) {
 async function addGraderCriterion(page, criterion) {
     await switchToGraderSubTab(page, 'rubric');
     const addButton = criteriaSection(page).getByTestId('grader-add-criterion-button');
-    await test$1.expect(addButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(addButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await addButton.click();
     await submitCriterionModal(page, criterion);
-    await test$1.expect(criterionRow(page, criterion.name)).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(criterionRow(page, criterion.name)).toBeVisible({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Added rubric criterion "${criterion.name}"`);
 }
 /**
@@ -4555,7 +4578,7 @@ async function editGraderCriterion(page, currentName, updates) {
     await switchToGraderSubTab(page, 'rubric');
     await clickRowMenuAction(page, currentName, GRADER_LABELS.menu.edit);
     await submitCriterionModal(page, updates);
-    await test$1.expect(criterionRow(page, updates.name)).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(criterionRow(page, updates.name)).toBeVisible({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Edited rubric criterion "${currentName}" → "${updates.name}"`);
 }
 /**
@@ -4567,12 +4590,12 @@ async function deleteGraderCriterion(page, name) {
     await switchToGraderSubTab(page, 'rubric');
     await clickRowMenuAction(page, name, GRADER_LABELS.menu.delete);
     const modal = page.getByTestId('grader-criterion-delete-modal');
-    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT$1 });
     const confirmButton = modal.getByTestId('grader-criterion-delete-confirm');
-    await test$1.expect(confirmButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(confirmButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await confirmButton.click();
-    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT });
-    await test$1.expect(criterionRow(page, name)).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT$1 });
+    await test$1.expect(criterionRow(page, name)).toBeHidden({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Deleted rubric criterion "${name}"`);
 }
 /**
@@ -4583,18 +4606,18 @@ async function deleteGraderCriterion(page, name) {
 async function expectLastCriterionDeleteDisabled(page, name) {
     await switchToGraderSubTab(page, 'rubric');
     await test$1.expect(criteriaSection(page).getByTestId('grader-last-criterion-hint')).toBeVisible({
-        timeout: UI_TIMEOUT,
+        timeout: UI_TIMEOUT$1,
     });
     const trigger = criterionRow(page, name).getByRole('button', {
         name: GRADER_LABELS.menu.actionsAria(name),
     });
-    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await trigger.click();
     const deleteItem = page.getByRole('menuitem', { name: GRADER_LABELS.menu.delete, exact: true });
-    await test$1.expect(deleteItem).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(deleteItem).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await test$1.expect(deleteItem).toHaveAttribute('aria-disabled', 'true');
     await page.keyboard.press('Escape');
-    await test$1.expect(deleteItem).toBeHidden({ timeout: UI_TIMEOUT });
+    await test$1.expect(deleteItem).toBeHidden({ timeout: UI_TIMEOUT$1 });
 }
 /**
  * Assert whether the amber misconfiguration banner is shown (grading on
@@ -4604,7 +4627,7 @@ async function expectLastCriterionDeleteDisabled(page, name) {
 async function expectGraderMisconfiguredWarning(page, visible) {
     const warning = graderTabBody(page).getByTestId('grader-misconfigured-warning');
     if (visible) {
-        await test$1.expect(warning).toBeVisible({ timeout: UI_TIMEOUT });
+        await test$1.expect(warning).toBeVisible({ timeout: UI_TIMEOUT$1 });
     }
     else {
         await test$1.expect(warning).toBeHidden();
@@ -4613,7 +4636,7 @@ async function expectGraderMisconfiguredWarning(page, visible) {
 /** Assert the rubric's live "total possible points" readout (Rubric sub-tab). */
 async function expectGraderTotalPoints(page, total) {
     await switchToGraderSubTab(page, 'rubric');
-    await test$1.expect(criteriaSection(page).getByText(`Total Possible Points: ${total}`, { exact: true })).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(criteriaSection(page).getByText(`Total Possible Points: ${total}`, { exact: true })).toBeVisible({ timeout: UI_TIMEOUT$1 });
 }
 /** The Results sub-tab's section within the tab body. */
 function resultsSection(page) {
@@ -4633,21 +4656,21 @@ function gradeResultRow(page, email) {
 async function filterGradeResultsByEmail(page, email) {
     await switchToGraderSubTab(page, 'results');
     const trigger = resultsSection(page).getByTestId('grader-results-user-filter');
-    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await trigger.click();
     const searchBox = resultsSection(page).getByPlaceholder(GRADER_LABELS.results.searchUsersPlaceholder);
-    await test$1.expect(searchBox).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(searchBox).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await searchBox.fill(email);
     const option = resultsSection(page).getByRole('option', { name: email });
-    await test$1.expect(option).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(option).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await option.click();
-    await test$1.expect(gradeResultRow(page, email)).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(gradeResultRow(page, email)).toBeVisible({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Filtered grade results by learner "${email}"`);
 }
 /** Assert a grade-result row for the given learner email is visible. */
 async function expectGradeResultRow(page, email) {
     await switchToGraderSubTab(page, 'results');
-    await test$1.expect(gradeResultRow(page, email)).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(gradeResultRow(page, email)).toBeVisible({ timeout: UI_TIMEOUT$1 });
 }
 /**
  * Override a learner's grade via the row's three-dots menu → Override grade
@@ -4659,10 +4682,10 @@ async function overrideGradeResult(page, email, values) {
     const overrideButton = gradeResultRow(page, email).getByRole('button', {
         name: GRADER_LABELS.results.overrideButtonAria(email),
     });
-    await test$1.expect(overrideButton).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(overrideButton).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await overrideButton.click();
     const modal = page.getByTestId('grader-override-modal');
-    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await modal
         .getByLabel(GRADER_LABELS.results.modal.pointsLabel, { exact: true })
         .fill(String(values.points));
@@ -4672,9 +4695,9 @@ async function overrideGradeResult(page, email, values) {
             .fill(values.feedback);
     }
     const saveButton = modal.getByTestId('grader-override-save');
-    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await saveButton.click();
-    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Overrode grade for "${email}" with ${values.points} points`);
 }
 /**
@@ -4686,14 +4709,14 @@ async function clearGradeResultOverride(page, email) {
     const overrideButton = gradeResultRow(page, email).getByRole('button', {
         name: GRADER_LABELS.results.overrideButtonAria(email),
     });
-    await test$1.expect(overrideButton).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(overrideButton).toBeVisible({ timeout: UI_TIMEOUT$1 });
     await overrideButton.click();
     const modal = page.getByTestId('grader-override-modal');
-    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT$1 });
     const clearButton = modal.getByTestId('grader-override-clear');
-    await test$1.expect(clearButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await test$1.expect(clearButton).toBeEnabled({ timeout: UI_TIMEOUT$1 });
     await clearButton.click();
-    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT$1 });
     logger.info(`Cleared grade override for "${email}"`);
 }
 
@@ -4892,6 +4915,653 @@ async function clickBillingManageUsage(page) {
     await btn.click();
 }
 
+/**
+ * Spend limits ("Billing") helpers — Playwright bindings for the LLM
+ * spend-cap admin UI from `@iblai/web-containers`:
+ *
+ * - the **agent settings Billing tab** (`AgentSpendCapsTab`) with its
+ *   "This Agent" / "Per User" sub-tabs, the per-user table with a
+ *   three-dots row menu, and the add/edit user-limit modal (email-based
+ *   user picker), and
+ * - the **tenant settings Billing tab** with its "Plan & Credits" /
+ *   "Spend Limits" tabs and the workspace-wide limit section
+ *   (`SpendLimitsSection` inside `BillingTab`).
+ *
+ * Selector policy (flakiness-proof by construction):
+ * - Dialog-first scoping: every modal is resolved into a Locator variable
+ *   first (`user-cap-modal`, the delete dialogs, the edit-agent dialog, the
+ *   Agent Limits manage popup) and all sub-elements are queried from that
+ *   variable — never a bare page-wide match that could hit same-named
+ *   elements in nested portals.
+ * - Nested dialogs: the tenant Agent Limits tab opens the agent Billing
+ *   editor in a popup *on top of* the tenant settings dialog, so several
+ *   dialogs with tablists can be open at once. Every agent-scope helper
+ *   accepts an optional `scope` Locator (the host dialog) for that case;
+ *   `openAgentLimitsManage` returns the popup Locator to pass as `scope`.
+ * - Stable hooks only: `data-testid`, role + accessible name (aria-labels).
+ *   No CSS class or structural selectors.
+ * - No `waitForTimeout` / `networkidle`. Progress is gated on UI state that
+ *   only exists after the awaited transition: a section testid rendering, a
+ *   modal closing after its mutation resolves, a table row
+ *   appearing/disappearing after the list refetch, a success toast.
+ */
+const SPEND_LIMITS_LABELS = {
+    /** Agent-settings modal tab name (host registries label it "Billing"). */
+    tabName: 'Billing',
+    subTabs: {
+        agent: 'This Agent',
+        users: 'Per User',
+    },
+    tenantTabs: {
+        planAndCredits: 'Plan & Credits',
+        spendLimits: 'Spend Limits',
+        agentLimits: 'Agent Limits',
+    },
+    /** aria-label of the tenant Billing tab's tablist. */
+    tenantTablistAria: 'Billing sections',
+    addUserLimitButton: 'Add User Limit',
+    menu: {
+        /**
+         * aria-label template for a table row's three-dots trigger. Takes the
+         * DISPLAYED name — the user's email when the API provides one, username
+         * only as fallback. Helpers locate the trigger by its username-keyed
+         * testid instead (`user-cap-actions-<username>`), which is immune to
+         * that distinction; prefer the testid in new code.
+         */
+        actionsAria: (displayName) => `Actions for ${displayName}`,
+        edit: 'Edit',
+        delete: 'Delete',
+    },
+    toasts: {
+        saved: 'Spend limit saved',
+        deleted: 'Spend limit deleted',
+    },
+    intervalOptions: {
+        day: 'Day',
+        week: 'Week',
+        month: 'Month',
+        year: 'Year',
+    },
+    enforcementOptions: {
+        block: 'Block Requests',
+        alert_only: 'Alert Only',
+    },
+};
+const UI_TIMEOUT = 10000;
+const MUTATION_TIMEOUT = 15000;
+/**
+ * The dialog that hosts the agent settings tabs. Several dialogs can be
+ * open at once (the Agent Limits manage popup stacks on top of the tenant
+ * settings dialog, and both host a tablist), so this resolves to the
+ * TOPMOST match — stacked Radix dialogs portal to the end of `<body>` in
+ * mount order, making the last match the one on top. Helpers that must
+ * target a specific dialog take an explicit `scope` Locator instead, which
+ * always wins over this default.
+ */
+function editAgentDialog(page) {
+    return page
+        .getByRole('dialog')
+        .filter({ has: page.getByRole('tablist') })
+        .last();
+}
+/**
+ * The agent Billing tab's body. `scope` is the dialog hosting the editor
+ * (e.g. the Locator returned by `openAgentLimitsManage`); defaults to the
+ * topmost settings dialog.
+ */
+function spendLimitsTabBody(page, scope) {
+    return (scope !== null && scope !== void 0 ? scope : editAgentDialog(page)).getByTestId('spend-caps-tab-body');
+}
+/** The per-user limits section within the Billing tab body. */
+function userCapsSection(page, scope) {
+    return spendLimitsTabBody(page, scope).getByTestId('user-caps-section');
+}
+/** A per-user table row for the given username. */
+function userSpendLimitRow(page, username, scope) {
+    return userCapsSection(page, scope).getByTestId(`user-cap-row-${username}`);
+}
+/**
+ * Returns false if the Billing tab isn't currently rendered in the
+ * edit-agent dialog (host didn't register it, or RBAC hid it).
+ */
+async function isSpendLimitsTabVisible(page) {
+    const tab = editAgentDialog(page).getByRole('tab', {
+        name: SPEND_LIMITS_LABELS.tabName,
+        exact: true,
+    });
+    try {
+        await test$1.expect(tab).toBeVisible({ timeout: 5000 });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Switch to the Billing top-level tab of the edit-agent dialog. Completion
+ * is gated on the tab body's testid, not on timing.
+ */
+async function switchToSpendLimitsTab(page) {
+    const dialog = editAgentDialog(page);
+    const tab = dialog.getByRole('tab', { name: SPEND_LIMITS_LABELS.tabName, exact: true });
+    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT });
+    await tab.click();
+    await test$1.expect(spendLimitsTabBody(page)).toBeVisible({ timeout: UI_TIMEOUT });
+    logger.info('Switched to agent Billing (spend limits) tab');
+}
+/**
+ * Switch between the Billing tab's two sub-tabs. Completion is gated on the
+ * sub-tab's content rendering: the agent limit form (or its loading/denied
+ * states) for "agent", the per-user section (or its spinner) for "users".
+ * `scope` is the dialog hosting the editor (see `spendLimitsTabBody`).
+ */
+async function switchToSpendLimitsSubTab(page, subTab, scope) {
+    const body = spendLimitsTabBody(page, scope);
+    const trigger = body.getByTestId(`spend-caps-sub-tab-${subTab}`);
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await trigger.click();
+    const content = subTab === 'agent'
+        ? body
+            .getByTestId('agent-cap-form')
+            .or(body.getByTestId('agent-cap-loading'))
+            .or(body.getByTestId('spend-caps-denied'))
+        : body
+            .getByTestId('user-caps-section')
+            .or(body.getByTestId('user-caps-loading'))
+            .or(body.getByTestId('spend-caps-denied'));
+    await test$1.expect(content.first()).toBeVisible({ timeout: UI_TIMEOUT });
+    logger.info(`Switched to spend limits "${subTab}" sub-tab`);
+}
+/** Pick an option in one of the limit form's Radix selects. */
+async function pickSelectOption(scope, page, triggerTestId, label) {
+    const trigger = scope.getByTestId(triggerTestId);
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await trigger.click();
+    // Radix renders the listbox in a portal outside the scope — the open
+    // listbox is the only one in the document, so a role-level lookup is safe.
+    const option = page.getByRole('option', { name: label, exact: true });
+    await test$1.expect(option).toBeVisible({ timeout: UI_TIMEOUT });
+    await option.click();
+    await test$1.expect(option).toBeHidden({ timeout: UI_TIMEOUT });
+}
+/**
+ * Fill a spend-limit form (any scope — agent, workspace, or the user-limit
+ * modal). Only the provided fields are changed. `testIdPrefix` matches the
+ * form's testId prop: 'agent-cap', 'tenant-cap' or 'user-cap-modal'.
+ */
+async function fillSpendLimitForm(page, scope, testIdPrefix, values) {
+    if (values.enabled !== undefined) {
+        const toggle = scope.getByTestId(`${testIdPrefix}-enabled-switch`);
+        await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT });
+        if ((await toggle.getAttribute('aria-checked')) !== String(values.enabled)) {
+            await toggle.click();
+            await test$1.expect(toggle).toHaveAttribute('aria-checked', String(values.enabled), {
+                timeout: UI_TIMEOUT,
+            });
+        }
+    }
+    if (values.limitUsd !== undefined) {
+        const input = scope.getByTestId(`${testIdPrefix}-limit-input`);
+        await test$1.expect(input).toBeVisible({ timeout: UI_TIMEOUT });
+        await input.fill(String(values.limitUsd));
+    }
+    if (values.interval) {
+        await pickSelectOption(scope, page, `${testIdPrefix}-interval-select`, SPEND_LIMITS_LABELS.intervalOptions[values.interval]);
+    }
+    if (values.enforcement) {
+        await pickSelectOption(scope, page, `${testIdPrefix}-enforcement-select`, SPEND_LIMITS_LABELS.enforcementOptions[values.enforcement]);
+    }
+    if (values.alertThresholds !== undefined) {
+        const input = scope.getByTestId(`${testIdPrefix}-thresholds-input`);
+        await test$1.expect(input).toBeVisible({ timeout: UI_TIMEOUT });
+        await input.fill(values.alertThresholds);
+    }
+}
+/** Click a form's Save and gate on the saved toast (fires after the PUT resolves). */
+async function saveSpendLimitForm(page, scope, testIdPrefix) {
+    const saveButton = scope.getByTestId(`${testIdPrefix}-save-button`);
+    await test$1.expect(saveButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await saveButton.click();
+    // .first() is deliberate: repeated saves can stack identical sonner
+    // toasts, and any one of them proves the mutation resolved.
+    await test$1.expect(page.getByText(SPEND_LIMITS_LABELS.toasts.saved).first()).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+}
+/** Confirm a captured delete dialog and gate on it closing + the deleted toast. */
+async function confirmDeleteDialog(page, dialogTestId) {
+    const dialog = page.getByTestId(dialogTestId);
+    await test$1.expect(dialog).toBeVisible({ timeout: UI_TIMEOUT });
+    // All three delete dialogs share the '<x>-delete-modal' / '<x>-delete-confirm'
+    // testid convention.
+    const confirmButton = dialog.getByTestId(`${dialogTestId.replace('-modal', '')}-confirm`);
+    await test$1.expect(confirmButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await confirmButton.click();
+    await test$1.expect(dialog).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    await test$1.expect(page.getByText(SPEND_LIMITS_LABELS.toasts.deleted).first()).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+}
+/**
+ * Create or update the agent-scoped spend limit (switches to the "This
+ * agent" sub-tab first). Completion is gated on the saved toast and the
+ * usage strip rendering (it only exists once a cap is persisted).
+ */
+async function setAgentSpendLimit(page, values, scope) {
+    await switchToSpendLimitsSubTab(page, 'agent', scope);
+    const body = spendLimitsTabBody(page, scope);
+    await fillSpendLimitForm(page, body, 'agent-cap', values);
+    await saveSpendLimitForm(page, body, 'agent-cap');
+    await test$1.expect(body.getByTestId('agent-cap-usage')).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    logger.info('Saved agent spend limit');
+}
+/**
+ * Delete the agent-scoped spend limit via the form's Delete button →
+ * confirmation dialog. Completion is gated on the dialog closing, the
+ * deleted toast, and the form returning to create mode (no-cap hint).
+ */
+async function deleteAgentSpendLimit(page, scope) {
+    await switchToSpendLimitsSubTab(page, 'agent', scope);
+    const body = spendLimitsTabBody(page, scope);
+    const deleteButton = body.getByTestId('agent-cap-delete-button');
+    await test$1.expect(deleteButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await deleteButton.click();
+    await confirmDeleteDialog(page, 'spend-cap-delete-modal');
+    await test$1.expect(body.getByTestId('agent-cap-no-cap-hint')).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info('Deleted agent spend limit');
+}
+/**
+ * Fill the user-limit modal's form and save it. The modal Locator is
+ * captured once and every sub-element is resolved from it.
+ */
+async function submitUserCapModal(page, values) {
+    const modal = page.getByTestId('user-cap-modal');
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    await fillSpendLimitForm(page, modal, 'user-cap-modal', values);
+    await saveSpendLimitForm(page, modal, 'user-cap-modal');
+    // The modal only closes itself after the upsert resolves.
+    await test$1.expect(modal).toBeHidden({ timeout: MUTATION_TIMEOUT });
+}
+/**
+ * Add a per-user spend limit through the modal (switches to the "Per User"
+ * sub-tab first): opens the modal, searches the user by email, clicks the
+ * email in the results (the picker is email-only by design), fills the
+ * form, saves. Completion is gated on the modal closing and the user's
+ * table row rendering after the list refetch.
+ */
+async function addUserSpendLimit(page, values, scope) {
+    await switchToSpendLimitsSubTab(page, 'users', scope);
+    const addButton = userCapsSection(page, scope).getByTestId('user-caps-add-button');
+    await test$1.expect(addButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await addButton.click();
+    const modal = page.getByTestId('user-cap-modal');
+    await test$1.expect(modal).toBeVisible({ timeout: UI_TIMEOUT });
+    const pickerInput = modal.getByTestId('user-cap-modal-user-picker-input');
+    await test$1.expect(pickerInput).toBeVisible({ timeout: UI_TIMEOUT });
+    await pickerInput.fill(values.email);
+    // Options render as buttons labelled with the email only.
+    const option = modal
+        .getByTestId('user-cap-modal-user-picker-results')
+        .getByRole('button', { name: values.email, exact: true });
+    await test$1.expect(option).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await option.click();
+    await test$1.expect(modal.getByTestId('user-cap-modal-user-picker-selected')).toBeVisible({
+        timeout: UI_TIMEOUT,
+    });
+    await submitUserCapModal(page, values);
+    await test$1.expect(userSpendLimitRow(page, values.username, scope)).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info(`Added user spend limit for "${values.email}"`);
+}
+/**
+ * Open a per-user table row's three-dots menu and click one of its actions.
+ * The trigger is located by testid, not aria-label — the accessible name is
+ * email-first while rows stay keyed by username.
+ */
+async function clickUserRowMenuAction(page, username, action, scope) {
+    const trigger = userSpendLimitRow(page, username, scope).getByTestId(`user-cap-actions-${username}`);
+    await test$1.expect(trigger).toBeVisible({ timeout: UI_TIMEOUT });
+    await trigger.click();
+    // The menu portals to the page root — the open menu is the only one.
+    const item = page.getByRole('menuitem', { name: action, exact: true });
+    await test$1.expect(item).toBeVisible({ timeout: UI_TIMEOUT });
+    await item.click();
+}
+/**
+ * Edit an existing per-user limit via its row's three-dots menu → Edit
+ * modal. Completion is gated on the modal closing after the upsert.
+ */
+async function editUserSpendLimit(page, username, values, scope) {
+    await switchToSpendLimitsSubTab(page, 'users', scope);
+    await clickUserRowMenuAction(page, username, SPEND_LIMITS_LABELS.menu.edit, scope);
+    await submitUserCapModal(page, values);
+    logger.info(`Edited user spend limit for "${username}"`);
+}
+/**
+ * Idempotently flip a per-user limit's Status toggle (the switch in the
+ * table's Status column — datasets-table pattern, saves immediately).
+ * Completion is gated on the saved toast and the switch reflecting the new
+ * state after the row refetch.
+ */
+async function setUserSpendLimitEnabled(page, username, enabled, scope) {
+    await switchToSpendLimitsSubTab(page, 'users', scope);
+    const toggle = userSpendLimitRow(page, username, scope).getByTestId(`user-cap-status-switch-${username}`);
+    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT });
+    if ((await toggle.getAttribute('aria-checked')) === String(enabled)) {
+        logger.info(`User spend limit for "${username}" already ${enabled ? 'enabled' : 'disabled'}`);
+        return;
+    }
+    await test$1.expect(toggle).toBeEnabled({ timeout: UI_TIMEOUT });
+    await toggle.click();
+    await test$1.expect(page.getByText(SPEND_LIMITS_LABELS.toasts.saved).first()).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    await test$1.expect(toggle).toHaveAttribute('aria-checked', String(enabled), {
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info(`User spend limit for "${username}" ${enabled ? 'enabled' : 'disabled'}`);
+}
+/**
+ * Delete a per-user limit via its row's three-dots menu → confirmation
+ * dialog. Completion is gated on the dialog closing, the deleted toast and
+ * the row disappearing after the list refetch.
+ */
+async function deleteUserSpendLimit(page, username, scope) {
+    await switchToSpendLimitsSubTab(page, 'users', scope);
+    await clickUserRowMenuAction(page, username, SPEND_LIMITS_LABELS.menu.delete, scope);
+    await confirmDeleteDialog(page, 'user-cap-delete-modal');
+    await test$1.expect(userSpendLimitRow(page, username, scope)).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    logger.info(`Deleted user spend limit for "${username}"`);
+}
+// ---------------------------------------------------------------------------
+// Tenant settings — Billing tab ("Plan & Credits" / "Spend Limits")
+// ---------------------------------------------------------------------------
+/** The tenant Billing tab's tablist (scoped by its aria-label). */
+function tenantBillingTablist(page) {
+    return page.getByRole('tablist', { name: SPEND_LIMITS_LABELS.tenantTablistAria });
+}
+/** The workspace spend limit section card in the tenant Billing tab. */
+function workspaceSpendLimitSection(page) {
+    return page.getByTestId('spend-limits-workspace-section');
+}
+/**
+ * Switch the tenant Billing tab to "Spend Limits". Assumes the tenant
+ * settings Billing tab is already open (see `waitForBillingTabReady`).
+ * Completion is gated on the workspace section rendering.
+ */
+async function switchToWorkspaceSpendLimits(page) {
+    const tab = tenantBillingTablist(page).getByRole('tab', {
+        name: SPEND_LIMITS_LABELS.tenantTabs.spendLimits,
+        exact: true,
+    });
+    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT });
+    await tab.click();
+    await test$1.expect(workspaceSpendLimitSection(page)).toBeVisible({ timeout: UI_TIMEOUT });
+    logger.info('Switched to tenant Spend Limits tab');
+}
+/**
+ * Switch the tenant Billing tab back to "Plan & Credits". Completion is
+ * gated on the Plan section rendering.
+ */
+async function switchToPlanAndCredits(page) {
+    const tab = tenantBillingTablist(page).getByRole('tab', {
+        name: SPEND_LIMITS_LABELS.tenantTabs.planAndCredits,
+        exact: true,
+    });
+    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT });
+    await tab.click();
+    await test$1.expect(page.getByTestId('billing-plan-section')).toBeVisible({ timeout: UI_TIMEOUT });
+    logger.info('Switched to tenant Plan & Credits tab');
+}
+/**
+ * Create or update the workspace-wide spend limit (switches to the Spend
+ * Limits tab first). Completion is gated on the saved toast and the
+ * usage strip rendering (it only exists once a cap is persisted).
+ */
+async function setWorkspaceSpendLimit(page, values) {
+    await switchToWorkspaceSpendLimits(page);
+    const section = workspaceSpendLimitSection(page);
+    await fillSpendLimitForm(page, section, 'tenant-cap', values);
+    await saveSpendLimitForm(page, section, 'tenant-cap');
+    await test$1.expect(section.getByTestId('tenant-cap-usage')).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info('Saved workspace spend limit');
+}
+/**
+ * Delete the workspace-wide spend limit. Completion is gated on the dialog
+ * closing, the deleted toast, and the usage strip disappearing.
+ */
+async function deleteWorkspaceSpendLimit(page) {
+    await switchToWorkspaceSpendLimits(page);
+    const section = workspaceSpendLimitSection(page);
+    const deleteButton = section.getByTestId('tenant-cap-delete-button');
+    await test$1.expect(deleteButton).toBeEnabled({ timeout: UI_TIMEOUT });
+    await deleteButton.click();
+    await confirmDeleteDialog(page, 'tenant-cap-delete-modal');
+    await test$1.expect(section.getByTestId('tenant-cap-usage')).toBeHidden({
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info('Deleted workspace spend limit');
+}
+/**
+ * Assert the workspace usage strip (the same one the agent editor shows) is
+ * visible, optionally matching formatted dollar values like '$30.50' inside
+ * its "Spent: …" / "Remaining: …" texts.
+ */
+async function expectWorkspaceSpendStats(page, values) {
+    const section = workspaceSpendLimitSection(page);
+    const usage = section.getByTestId('tenant-cap-usage');
+    await test$1.expect(usage).toBeVisible({ timeout: UI_TIMEOUT });
+    if (values === null || values === void 0 ? void 0 : values.spent) {
+        await test$1.expect(section.getByTestId('tenant-cap-spent')).toContainText(values.spent);
+    }
+    if (values === null || values === void 0 ? void 0 : values.remaining) {
+        await test$1.expect(section.getByTestId('tenant-cap-remaining')).toContainText(values.remaining);
+    }
+}
+/**
+ * Assert the "actual spend" stats (financial analytics) shown while no
+ * workspace cap is configured yet.
+ */
+async function expectWorkspaceActualSpendStats(page) {
+    await test$1.expect(workspaceSpendLimitSection(page).getByTestId('workspace-actual-spend-stats')).toBeVisible({ timeout: UI_TIMEOUT });
+}
+// ---------------------------------------------------------------------------
+// Tenant settings — Billing tab, "Agent Limits" tab (configured caps table)
+// ---------------------------------------------------------------------------
+/** The Agent Limits section card in the tenant Billing tab. */
+function agentLimitsSection(page) {
+    return page.getByTestId('spend-limits-agents-section');
+}
+/** An Agent Limits table row for the given agent unique_id. */
+function agentLimitsRow(page, mentorUniqueId) {
+    return agentLimitsSection(page).getByTestId(`agent-limits-row-${mentorUniqueId}`);
+}
+/**
+ * Switch the tenant Billing tab to "Agent Limits". Assumes the tenant
+ * Billing tab is already open. Completion is gated on the section rendering.
+ */
+async function switchToAgentLimits(page) {
+    const tab = tenantBillingTablist(page).getByRole('tab', {
+        name: SPEND_LIMITS_LABELS.tenantTabs.agentLimits,
+        exact: true,
+    });
+    await test$1.expect(tab).toBeVisible({ timeout: UI_TIMEOUT });
+    await tab.click();
+    await test$1.expect(agentLimitsSection(page)).toBeVisible({ timeout: UI_TIMEOUT });
+    logger.info('Switched to tenant Agent Limits tab');
+}
+/**
+ * Filter the Agent Limits table to one agent via the autocomplete: types the
+ * name, clicks the matching option, and gates on the selected chip.
+ */
+async function filterAgentLimits(page, agentName) {
+    const section = agentLimitsSection(page);
+    const input = section.getByTestId('agent-limits-filter-input');
+    await test$1.expect(input).toBeVisible({ timeout: UI_TIMEOUT });
+    await input.fill(agentName);
+    const option = section
+        .getByTestId('agent-limits-filter-results')
+        .getByRole('button', { name: agentName, exact: true });
+    await test$1.expect(option).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    await option.click();
+    await test$1.expect(section.getByTestId('agent-limits-filter-selected')).toBeVisible({
+        timeout: UI_TIMEOUT,
+    });
+    logger.info(`Filtered agent limits to "${agentName}"`);
+}
+/** Clear the Agent Limits autocomplete filter (back to the full caps list). */
+async function clearAgentLimitsFilter(page) {
+    const section = agentLimitsSection(page);
+    const clearButton = section.getByTestId('agent-limits-filter-clear');
+    await test$1.expect(clearButton).toBeVisible({ timeout: UI_TIMEOUT });
+    await clearButton.click();
+    await test$1.expect(section.getByTestId('agent-limits-filter-input')).toBeVisible({
+        timeout: UI_TIMEOUT,
+    });
+}
+/** Gate on the Agent Limits manage popup being open with the Billing editor loaded. */
+async function expectAgentLimitsPopupOpen(page) {
+    const popup = page.getByTestId('agent-limits-modal');
+    await test$1.expect(popup).toBeVisible({ timeout: UI_TIMEOUT });
+    await test$1.expect(popup.getByTestId('spend-caps-tab-body')).toBeVisible({ timeout: UI_TIMEOUT });
+    return popup;
+}
+/**
+ * Open the manage popup for a capped agent's row and return the popup's
+ * Locator. The popup hosts the same `AgentSpendCapsTab` editor as the
+ * agent's own settings and stacks ON TOP of the tenant settings dialog, so
+ * pass the returned Locator as the `scope` argument of the agent-scope
+ * helpers (`setAgentSpendLimit`, `addUserSpendLimit`, …) — that pins every
+ * query to the popup instead of the dialog underneath.
+ */
+async function openAgentLimitsManage(page, mentorUniqueId) {
+    const manageButton = agentLimitsRow(page, mentorUniqueId).getByTestId(`agent-limits-manage-${mentorUniqueId}`);
+    await test$1.expect(manageButton).toBeVisible({ timeout: UI_TIMEOUT });
+    await manageButton.click();
+    const popup = await expectAgentLimitsPopupOpen(page);
+    logger.info(`Opened agent limits popup for "${mentorUniqueId}"`);
+    return popup;
+}
+/**
+ * With the filter set to an agent that has no cap yet, click the empty
+ * state's "Set Spend Limit" button and return the opened popup's Locator
+ * (pass it as `scope` to the agent-scope helpers, see
+ * `openAgentLimitsManage`).
+ */
+async function clickSetSpendLimitForFilteredAgent(page) {
+    const button = agentLimitsSection(page).getByTestId('agent-limits-set-limit-button');
+    await test$1.expect(button).toBeVisible({ timeout: UI_TIMEOUT });
+    await button.click();
+    const popup = await expectAgentLimitsPopupOpen(page);
+    logger.info('Opened agent limits popup from the filtered empty state');
+    return popup;
+}
+/** Close the Agent Limits manage popup (Escape) and gate on it disappearing. */
+async function closeAgentLimitsPopup(page) {
+    const popup = page.getByTestId('agent-limits-modal');
+    await test$1.expect(popup).toBeVisible({ timeout: UI_TIMEOUT });
+    await page.keyboard.press('Escape');
+    await test$1.expect(popup).toBeHidden({ timeout: UI_TIMEOUT });
+}
+/**
+ * Idempotently flip an agent cap's Status toggle in the Agent Limits table
+ * (saves immediately). Gates on the saved toast and the switch reflecting
+ * the new state after the list refetch.
+ */
+async function setAgentLimitsRowEnabled(page, mentorUniqueId, enabled) {
+    const toggle = agentLimitsRow(page, mentorUniqueId).getByTestId(`agent-limits-status-switch-${mentorUniqueId}`);
+    await test$1.expect(toggle).toBeVisible({ timeout: UI_TIMEOUT });
+    if ((await toggle.getAttribute('aria-checked')) === String(enabled)) {
+        logger.info(`Agent cap "${mentorUniqueId}" already ${enabled ? 'enabled' : 'disabled'}`);
+        return;
+    }
+    await test$1.expect(toggle).toBeEnabled({ timeout: UI_TIMEOUT });
+    await toggle.click();
+    await test$1.expect(page.getByText(SPEND_LIMITS_LABELS.toasts.saved).first()).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    await test$1.expect(toggle).toHaveAttribute('aria-checked', String(enabled), {
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info(`Agent cap "${mentorUniqueId}" ${enabled ? 'enabled' : 'disabled'}`);
+}
+/**
+ * Assert an Agent Limits row is visible, optionally checking its formatted
+ * cell contents, e.g. `{ name: 'Math Tutor', limit: '$250.00', spent: '$30.50' }`.
+ * Text matching is substring-based so a limit can be checked with or without
+ * its "/ Month" interval suffix.
+ */
+async function expectAgentLimitsRowContent(page, mentorUniqueId, texts) {
+    const row = agentLimitsRow(page, mentorUniqueId);
+    await test$1.expect(row).toBeVisible({ timeout: UI_TIMEOUT });
+    for (const text of Object.values(texts !== null && texts !== void 0 ? texts : {})) {
+        if (text)
+            await test$1.expect(row).toContainText(text);
+    }
+}
+// ---------------------------------------------------------------------------
+// Tenant settings — end-to-end composites through the manage popup
+// ---------------------------------------------------------------------------
+/**
+ * End to end from the tenant Agent Limits tab, for an agent with NO cap yet:
+ * filter to the agent by name, open the popup from the empty state's "Set
+ * Spend Limit" button, save the agent-scoped limit inside the popup, close
+ * it, and gate on the agent's row rendering after the list refetch.
+ */
+async function createAgentSpendLimitViaFilter(page, agent, values) {
+    await filterAgentLimits(page, agent.name);
+    const popup = await clickSetSpendLimitForFilteredAgent(page);
+    await setAgentSpendLimit(page, values, popup);
+    await closeAgentLimitsPopup(page);
+    await test$1.expect(agentLimitsRow(page, agent.mentorUniqueId)).toBeVisible({
+        timeout: MUTATION_TIMEOUT,
+    });
+    logger.info(`Created agent spend limit for "${agent.name}" via the Agent Limits filter`);
+}
+/**
+ * End to end from the tenant Agent Limits tab: open a capped agent's manage
+ * popup, save the agent-scoped limit inside it, close the popup, and gate on
+ * the row still rendering after the list refetch.
+ */
+async function setAgentSpendLimitFromTenantBilling(page, mentorUniqueId, values) {
+    const popup = await openAgentLimitsManage(page, mentorUniqueId);
+    await setAgentSpendLimit(page, values, popup);
+    await closeAgentLimitsPopup(page);
+    await test$1.expect(agentLimitsRow(page, mentorUniqueId)).toBeVisible({ timeout: MUTATION_TIMEOUT });
+    logger.info(`Saved agent spend limit for "${mentorUniqueId}" from tenant Billing`);
+}
+/**
+ * End to end from the tenant Agent Limits tab: open the agent's manage popup
+ * and delete its agent-scoped limit through the confirmation dialog. Closing
+ * the popup afterwards gates on the agent's row disappearing from the table
+ * (the tenant-wide list only holds configured caps).
+ */
+async function deleteAgentSpendLimitFromTenantBilling(page, mentorUniqueId) {
+    const popup = await openAgentLimitsManage(page, mentorUniqueId);
+    await deleteAgentSpendLimit(page, popup);
+    await closeAgentLimitsPopup(page);
+    await test$1.expect(agentLimitsRow(page, mentorUniqueId)).toBeHidden({ timeout: MUTATION_TIMEOUT });
+    logger.info(`Deleted agent spend limit for "${mentorUniqueId}" from tenant Billing`);
+}
+/**
+ * End to end per-user limit from the tenant Agent Limits tab: open the
+ * agent's manage popup, add the user limit through its "Per User" sub-tab
+ * (nested user-cap modal inside the popup), then close the popup. Completion
+ * is gated inside `addUserSpendLimit` on the modal closing and the user's
+ * row rendering in the popup's table.
+ */
+async function addUserSpendLimitFromTenantBilling(page, mentorUniqueId, values) {
+    const popup = await openAgentLimitsManage(page, mentorUniqueId);
+    await addUserSpendLimit(page, values, popup);
+    await closeAgentLimitsPopup(page);
+    logger.info(`Added user spend limit for "${values.email}" on "${mentorUniqueId}" from tenant Billing`);
+}
+
 /**
  * Tasks tab helpers — Playwright bindings for the `AgentTasksTab`
  * component from `@iblai/web-containers`.
@@ -7193,6 +7863,7 @@ exports.LTI_TEST_IDS = LTI_TEST_IDS;
 exports.MailsacClient = MailsacClient;
 exports.PRIVACY_LABELS = PRIVACY_LABELS;
 exports.SCREENSHARE_LABELS = SCREENSHARE_LABELS;
+exports.SPEND_LIMITS_LABELS = SPEND_LIMITS_LABELS;
 exports.SUPPORT_LABELS = SUPPORT_LABELS;
 exports.TASKS_LABELS = TASKS_LABELS;
 exports.VOICE_LABELS = VOICE_LABELS;
@@ -7202,6 +7873,10 @@ exports.addMemory = addMemory;
 exports.addQaPairsManually = addQaPairsManually;
 exports.addSkillToAgent = addSkillToAgent;
 exports.addTextResource = addTextResource;
+exports.addUserSpendLimit = addUserSpendLimit;
+exports.addUserSpendLimitFromTenantBilling = addUserSpendLimitFromTenantBilling;
+exports.agentLimitsRow = agentLimitsRow;
+exports.agentLimitsSection = agentLimitsSection;
 exports.archiveFirstMemory = archiveFirstMemory;
 exports.archiveMemoryByContent = archiveMemoryByContent;
 exports.billingAutoRechargeSection = billingAutoRechargeSection;
@@ -7220,6 +7895,7 @@ exports.cancelNewInstanceDialog = cancelNewInstanceDialog;
 exports.cancelStartEvaluation = cancelStartEvaluation;
 exports.checkAdminStatus = checkAdminStatus;
 exports.checkRunStatus = checkRunStatus;
+exports.clearAgentLimitsFilter = clearAgentLimitsFilter;
 exports.clearDateRangeFilter = clearDateRangeFilter;
 exports.clearGradeResultOverride = clearGradeResultOverride;
 exports.clearInstanceSearch = clearInstanceSearch;
@@ -7232,6 +7908,8 @@ exports.clickBillingUpgrade = clickBillingUpgrade;
 exports.clickChatPrivacyToggle = clickChatPrivacyToggle;
 exports.clickDownloadAgain = clickDownloadAgain;
 exports.clickManualDownloadLink = clickManualDownloadLink;
+exports.clickSetSpendLimitForFilteredAgent = clickSetSpendLimitForFilteredAgent;
+exports.closeAgentLimitsPopup = closeAgentLimitsPopup;
 exports.closeBenchmarkItemsDialog = closeBenchmarkItemsDialog;
 exports.closeCreditBalanceDropdown = closeCreditBalanceDropdown;
 exports.closeEvaluationDetailDialog = closeEvaluationDetailDialog;
@@ -7242,6 +7920,7 @@ exports.confirmEnableChatPrivacyMidSession = confirmEnableChatPrivacyMidSession;
 exports.confirmKeyDelete = confirmKeyDelete;
 exports.connectToInstance = connectToInstance;
 exports.copyEndpoint = copyEndpoint;
+exports.createAgentSpendLimitViaFilter = createAgentSpendLimitViaFilter;
 exports.createAuthSetup = createAuthSetup;
 exports.createBenchmark = createBenchmark;
 exports.createEnvConfig = createEnvConfig;
@@ -7255,6 +7934,8 @@ exports.createTool = createTool;
 exports.creditBalancePanel = creditBalancePanel;
 exports.creditBalancePlanBadge = creditBalancePlanBadge;
 exports.creditBalanceTrigger = creditBalanceTrigger;
+exports.deleteAgentSpendLimit = deleteAgentSpendLimit;
+exports.deleteAgentSpendLimitFromTenantBilling = deleteAgentSpendLimitFromTenantBilling;
 exports.deleteEvaluation = deleteEvaluation;
 exports.deleteFirstMemory = deleteFirstMemory;
 exports.deleteGraderCriterion = deleteGraderCriterion;
@@ -7265,6 +7946,8 @@ exports.deleteQaItem = deleteQaItem;
 exports.deleteResource = deleteResource;
 exports.deleteSkill = deleteSkill;
 exports.deleteTask = deleteTask;
+exports.deleteUserSpendLimit = deleteUserSpendLimit;
+exports.deleteWorkspaceSpendLimit = deleteWorkspaceSpendLimit;
 exports.disableSkill = disableSkill;
 exports.disableSupport = disableSupport;
 exports.disconnectInstance = disconnectInstance;
@@ -7275,10 +7958,12 @@ exports.editLink = editLink;
 exports.editSkill = editSkill;
 exports.editTextResource = editTextResource;
 exports.editTool = editTool;
+exports.editUserSpendLimit = editUserSpendLimit;
 exports.enableSkill = enableSkill;
 exports.enableSupport = enableSupport;
 exports.expandReview = expandReview;
 exports.expandTrace = expandTrace;
+exports.expectAgentLimitsRowContent = expectAgentLimitsRowContent;
 exports.expectAllEndpointsVisible = expectAllEndpointsVisible;
 exports.expectBenchmarkListed = expectBenchmarkListed;
 exports.expectBillingAutoRechargeSection = expectBillingAutoRechargeSection;
@@ -7362,9 +8047,12 @@ exports.expectTraceScore = expectTraceScore;
 exports.expectTtsSelectDisabled = expectTtsSelectDisabled;
 exports.expectVoiceProviderSelected = expectVoiceProviderSelected;
 exports.expectVoiceVisible = expectVoiceVisible;
+exports.expectWorkspaceActualSpendStats = expectWorkspaceActualSpendStats;
+exports.expectWorkspaceSpendStats = expectWorkspaceSpendStats;
 exports.exportRunCsv = exportRunCsv;
 exports.fillLinkName = fillLinkName;
 exports.fillToolForm = fillToolForm;
+exports.filterAgentLimits = filterAgentLimits;
 exports.filterByAction = filterByAction;
 exports.filterByActionAndVerify = filterByActionAndVerify;
 exports.filterByActor = filterByActor;
@@ -7487,6 +8175,7 @@ exports.isPrivateModeTabVisible = isPrivateModeTabVisible;
 exports.isSandboxTabVisible = isSandboxTabVisible;
 exports.isScreenShareTabVisible = isScreenShareTabVisible;
 exports.isSkillEnabled = isSkillEnabled;
+exports.isSpendLimitsTabVisible = isSpendLimitsTabVisible;
 exports.isSupportEnabled = isSupportEnabled;
 exports.isSupportTabVisible = isSupportTabVisible;
 exports.isTasksTabVisible = isTasksTabVisible;
@@ -7501,6 +8190,7 @@ exports.navigateToDataReports = navigateToDataReports;
 exports.navigateToReportDownload = navigateToReportDownload;
 exports.openAddItemsDialog = openAddItemsDialog;
 exports.openAddMemoryDialog = openAddMemoryDialog;
+exports.openAgentLimitsManage = openAgentLimitsManage;
 exports.openAgentPromptEditModal = openAgentPromptEditModal;
 exports.openBenchmarkItems = openBenchmarkItems;
 exports.openCallConfigVoicePicker = openCallConfigVoicePicker;
@@ -7581,8 +8271,12 @@ exports.selectTtsProvider = selectTtsProvider;
 exports.selectVoice = selectVoice;
 exports.selectVoiceProvider = selectVoiceProvider;
 exports.sendAgentChatMessage = sendAgentChatMessage;
+exports.setAgentLimitsRowEnabled = setAgentLimitsRowEnabled;
+exports.setAgentSpendLimit = setAgentSpendLimit;
+exports.setAgentSpendLimitFromTenantBilling = setAgentSpendLimitFromTenantBilling;
 exports.setBlockMessage = setBlockMessage;
 exports.setCallLanguage = setCallLanguage;
+exports.setCatalogSkillEnabled = setCatalogSkillEnabled;
 exports.setEnableVideo = setEnableVideo;
 exports.setEntitySelected = setEntitySelected;
 exports.setGradingEnabled = setGradingEnabled;
@@ -7592,6 +8286,8 @@ exports.setSupportEnabled = setSupportEnabled;
 exports.setTenantChatPrivacyEnabled = setTenantChatPrivacyEnabled;
 exports.setTicketStatus = setTicketStatus;
 exports.setUseFunctionCallingEnabled = setUseFunctionCallingEnabled;
+exports.setUserSpendLimitEnabled = setUserSpendLimitEnabled;
+exports.setWorkspaceSpendLimit = setWorkspaceSpendLimit;
 exports.setupSandboxInstance = setupSandboxInstance;
 exports.shouldAddNewRowWhenClickingAddRowButton = shouldAddNewRowWhenClickingAddRowButton;
 exports.shouldAllowEditingCellValuesInCSVEditor = shouldAllowEditingCellValuesInCSVEditor;
@@ -7610,11 +8306,13 @@ exports.shouldSaveEditedCSVAndTriggerDownload = shouldSaveEditedCSVAndTriggerDow
 exports.shouldShowCombiningReportsDialog = shouldShowCombiningReportsDialog;
 exports.shouldVerifyCSVEditorDialogAccessibility = shouldVerifyCSVEditorDialogAccessibility;
 exports.signUpWithEmailAndPassword = signUpWithEmailAndPassword;
+exports.spendLimitsTabBody = spendLimitsTabBody;
 exports.startEvaluation = startEvaluation;
 exports.submitLinkModal = submitLinkModal;
 exports.submitLlmJudge = submitLlmJudge;
 exports.submitToolModal = submitToolModal;
 exports.switchToAddItemsSubTab = switchToAddItemsSubTab;
+exports.switchToAgentLimits = switchToAgentLimits;
 exports.switchToAgentSkillsSubTab = switchToAgentSkillsSubTab;
 exports.switchToAvailableSkillsSubTab = switchToAvailableSkillsSubTab;
 exports.switchToEvaluationTab = switchToEvaluationTab;
@@ -7623,16 +8321,20 @@ exports.switchToGraderTab = switchToGraderTab;
 exports.switchToLtiSubTab = switchToLtiSubTab;
 exports.switchToLtiTab = switchToLtiTab;
 exports.switchToMemoryTab = switchToMemoryTab;
+exports.switchToPlanAndCredits = switchToPlanAndCredits;
 exports.switchToPrivacyTab = switchToPrivacyTab;
 exports.switchToPrivateModeTab = switchToPrivateModeTab;
 exports.switchToSandboxTab = switchToSandboxTab;
 exports.switchToScreenShareTab = switchToScreenShareTab;
 exports.switchToSkillResourcesSubTab = switchToSkillResourcesSubTab;
 exports.switchToSkillsTab = switchToSkillsTab;
+exports.switchToSpendLimitsSubTab = switchToSpendLimitsSubTab;
+exports.switchToSpendLimitsTab = switchToSpendLimitsTab;
 exports.switchToSupportTab = switchToSupportTab;
 exports.switchToTasksTab = switchToTasksTab;
 exports.switchToVoiceSubTab = switchToVoiceSubTab;
 exports.switchToVoiceTab = switchToVoiceTab;
+exports.switchToWorkspaceSpendLimits = switchToWorkspaceSpendLimits;
 exports.teardownSandboxInstance = teardownSandboxInstance;
 exports.test = test;
 exports.toggleAutoPush = toggleAutoPush;
@@ -7641,6 +8343,7 @@ exports.toggleSkill = toggleSkill;
 exports.toolFields = toolFields;
 exports.uploadAssetResource = uploadAssetResource;
 exports.uploadQaCsv = uploadQaCsv;
+exports.userSpendLimitRow = userSpendLimitRow;
 exports.verifyAgentConfigPromptsVisible = verifyAgentConfigPromptsVisible;
 exports.verifyAgentSkillsEmptyState = verifyAgentSkillsEmptyState;
 exports.verifyAuditLogEmptyState = verifyAuditLogEmptyState;
@@ -7676,4 +8379,5 @@ exports.waitForPageLoad = waitForPageLoad;
 exports.waitForPageReady = waitForPageReady;
 exports.waitForReportDownload = waitForReportDownload;
 exports.waitForTicketInList = waitForTicketInList;
+exports.workspaceSpendLimitSection = workspaceSpendLimitSection;
 //# sourceMappingURL=index.cjs.map