@jxsuite/studio 4.0.0 → 5.0.0

package/src/services/ai-tools.ts

@@ -12,7 +12,6 @@ import { createToolDefinition } from "@jxsuite/ai/tools";
 import type { ToolRegistry, ToolResult } from "@jxsuite/ai/tools";
 import type { JxMutableNode, JxPath, JxStateDefinition } from "@jxsuite/schema/types";
 import { getNodeAtPath } from "../state";
-import { toRaw } from "../reactivity";
 import type { Tab } from "../tabs/tab";
 import {
   beginBatch,
@@ -20,7 +19,6 @@ import {
   isBatching,
   mutateInsertNode,
   mutateMoveNode,
-  mutateRemoveNode,
   mutateUpdateProperty,
   mutateUpdateStyle,
   transactDoc,
@@ -28,7 +26,18 @@ import {
 import type { JxNodeValue } from "../tabs/transact";
 import { validateDoc } from "./jx-validate";
 import { recordWrite } from "./ai-writes";
-import { flagHardcodedTokens, formatTokenHints } from "./token-lint";
+import { serializeJson } from "../files/json-layout";
+import {
+  reportDocumentWrite,
+  snapshotBeforeWrite,
+  translateValidationError,
+} from "./ai-write-report";
+import type { RenderVerdict } from "./ai-write-report";
+
+/* Re-exported from its new home so `ai-project-tools.ts` and the tests keep their import: the
+   translation moved with the verdict it belongs to (`ai-write-report.ts`), where every document
+   write — hand-registered or projected from a command record — now reads it. */
+export { translateValidationError } from "./ai-write-report";
 
 const PATH_DESCRIPTION =
   "Path to a node in the document, as a JSON array of keys/indices from the root " +
@@ -45,74 +54,17 @@ function noDocError(): ToolResult {
 }
 
 /**
- * Translate a raw JSON Schema validation error into a Jx-specific actionable message. The LLM needs
- * concrete guidance on HOW to fix errors, not just what rule was violated. Shared with the
- * project-level file tools (ai-project-tools.ts), which pre-validate Jx documents before writing.
- *
- * @param {string} rawError - Message from ajv (e.g. "/children/0/style: must NOT have additional
- *   property")
- * @returns {string}
- */
-export function translateValidationError(rawError: string): string {
-  const lower = rawError.toLowerCase();
-
-  // Additional property — extract the offending key from the message if present
-  if (
-    lower.includes("must not have additional property") ||
-    lower.includes("additional properties")
-  ) {
-    return `${rawError}\n  → Fix: Remove or move the unexpected property. Style properties must be camelCase (e.g. "backgroundColor", not "background-color"). Non-IDL HTML attributes (aria-*, data-*, role, ...) must go inside an "attributes" object: { "attributes": { "aria-label": "..." } }.`;
-  }
-
-  // Pattern — usually tagName hyphen rule
-  if (lower.includes("must match pattern")) {
-    return `${rawError}\n  → Fix: Custom element tag names must contain a hyphen (e.g. "newsletter-form", "feature-card"). Standard HTML elements use their exact name (e.g. "div", "input", "button").`;
-  }
-
-  // Type error
-  if (lower.includes("must be string")) {
-    return `${rawError}\n  → Fix: Wrap the value in quotes — all Jx property values should be strings. For example, use "10px" (string) not 10px (unquoted).`;
-  }
-
-  if (lower.includes("must be number") || lower.includes("must be integer")) {
-    return `${rawError}\n  → Fix: Remove quotes from the numeric value — it should be a plain number, not a string.`;
-  }
-
-  if (lower.includes("must be object") || lower.includes("must be array")) {
-    return `${rawError}\n  → Fix: The value must be an object/array (use {} or []), not a string or number.`;
-  }
-
-  if (lower.includes("must be boolean")) {
-    return `${rawError}\n  → Fix: Use true or false without quotes for boolean values.`;
-  }
-
-  // Required property
-  if (lower.includes("must have required property")) {
-    return `${rawError}\n  → Fix: Add the missing required property. Every Jx element must have at least a "tagName" field.`;
-  }
-
-  // Enum / allowed values
-  if (lower.includes("must be equal to one of the allowed values")) {
-    return `${rawError}\n  → Fix: Change the value to one of the allowed options listed in the error.`;
-  }
-
-  return rawError;
-}
-
-/**
- * Apply a mutation, then validate the document and report only the schema errors the edit newly
- * introduced (the eval signal — ADR §6b). The change stays applied either way (optimistic apply +
- * undo, ADR §5); reporting the errors lets the agent loop self-correct on the next round.
- *
- * When a renderCheck function is provided, a second gate runs after schema validation passes: the
- * mutated document is rendered in a detached DOM context and any render-time throws are surfaced as
- * tool errors (same contract as schema errors).
+ * Apply a mutation, then hand the verdict to `ai-write-report.ts`: only the schema errors the edit
+ * NEWLY introduced are reported (the eval signal — ADR §6b), the render check runs when a
+ * renderCheck was provided and rendering worked before, and a success carries the token hints. The
+ * change stays applied either way (optimistic apply + undo, ADR §5); reporting the errors lets the
+ * agent loop self-correct on the next round.
  *
  * @param {import("../tabs/tab").Tab} tab
  * @param {(t: import("../tabs/tab").Tab) => void} mutationFn
  * @param {string} summary
  * @param {(doc: unknown) => Promise<string[]>} validate
- * @param {((doc: unknown) => Promise<{ ok: true } | { ok: false; error: string }>) | undefined} renderCheck
+ * @param {((doc: unknown) => Promise<RenderVerdict>) | undefined} renderCheck
  * @param {Record<string, string> | undefined} projectStyle
  * @returns {Promise<import("@jxsuite/ai/tools").ToolResult>}
  */
@@ -121,12 +73,11 @@ async function applyAndValidate(
   mutationFn: (t: Tab) => void,
   summary: string,
   validate: (doc: unknown) => Promise<string[]>,
-  renderCheck: ((doc: unknown) => Promise<{ ok: true } | { ok: false; error: string }>) | undefined,
+  renderCheck: ((doc: unknown) => Promise<RenderVerdict>) | undefined,
   projectStyle: Record<string, string> | undefined,
 ): Promise<ToolResult> {
-  const rawBefore = toRaw(tab.doc.document);
-  const before = new Set(await validate(rawBefore));
-  const renderOkBefore = renderCheck ? await renderCheck(rawBefore) : { ok: true };
+  const deps = { getProjectStyle: () => projectStyle, renderCheck, validate };
+  const before = await snapshotBeforeWrite(tab, deps);
 
   /* AND THE WRITE CAN BE REFUSED, in which case the model must be told rather than congratulated.
      The collab gate pauses structural editing while source is canonical, and this went on to
@@ -147,37 +98,7 @@ async function applyAndValidate(
      went through transactDoc, so the tab's history — and "Restore to here" — can reach it. */
   recordWrite({ disk: false, ok: true, path: tab.documentPath ?? "(untitled)", tool: summary });
 
-  const rawAfter = toRaw(tab.doc.document);
-  const after = await validate(rawAfter);
-  const newErrors = after.filter((e) => !before.has(e));
-  if (newErrors.length > 0) {
-    const formatted = newErrors.map((e) => `- ${translateValidationError(e)}`).join("\n");
-    return {
-      success: false,
-      error: `Change applied, but it introduced schema errors. Fix these issues with follow-up edits:\n${formatted}`,
-    };
-  }
-
-  if (renderCheck && renderOkBefore.ok) {
-    const renderResult = await renderCheck(rawAfter);
-    if (!renderResult.ok) {
-      return {
-        success: false,
-        error: `Change applied and schema-valid, but it broke rendering. Fix with follow-up edits:\n- ${renderResult.error}`,
-      };
-    }
-  }
-
-  // Soft token-discipline hints (never fail the mutation)
-  if (projectStyle) {
-    const findings = flagHardcodedTokens(rawAfter, projectStyle);
-    const hints = formatTokenHints(findings);
-    if (hints) {
-      return { success: true, summary: `${summary}\n\n${hints}` };
-    }
-  }
-
-  return { success: true, summary };
+  return reportDocumentWrite(tab, before, summary, deps);
 }
 
 /**
@@ -258,7 +179,7 @@ export function registerAiTools(
       name: "read_document",
       description:
         "Read the current Jx document, or the subtree at a given path. Use this to discover " +
-        "node paths before calling set_property, add_child, or remove_node.",
+        "node paths before calling set_property, add_child, or delete_node.",
       parameters: {
         type: "object",
         properties: {
@@ -751,7 +672,9 @@ export function registerAiTools(
           }
         }
         try {
-          await saveFile(relPath, JSON.stringify(content, null, 2));
+          // The save serializer, layout-less (`files/json-layout.ts`): the assistant supplied a
+          // Value, not a text, so the formatter's layout for fresh output is the right one.
+          await saveFile(relPath, serializeJson(content, null));
           recordWrite({ disk: true, ok: true, path: relPath, tool: "create_component" });
           return {
             success: true,
@@ -828,7 +751,8 @@ export function registerAiTools(
           }
         }
         try {
-          await saveFile(relPath, JSON.stringify(content, null, 2));
+          // As `create_component`: a value the assistant supplied, written in the formatter's layout.
+          await saveFile(relPath, serializeJson(content, null));
           recordWrite({ disk: true, ok: true, path: relPath, tool: "create_page" });
           return {
             success: true,
@@ -915,43 +839,4 @@ export function registerAiTools(
       },
     }),
   );
-
-  registry.register(
-    createToolDefinition({
-      name: "remove_node",
-      description: "Remove the node at the given path from its parent's children array.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "array",
-            description: `${PATH_DESCRIPTION} Cannot be the document root.`,
-            items: { type: ["string", "number"] },
-          },
-        },
-        required: ["path"],
-      },
-      async execute(args) {
-        const tab = getTab();
-        if (!tab) {
-          return noDocError();
-        }
-        const { path } = args as { path: JxPath };
-        if (path.length < 2) {
-          return { success: false, error: "Cannot remove the document root." };
-        }
-        if (getNodeAtPath(tab.doc.document, path) === undefined) {
-          return { success: false, error: `No node exists at path ${JSON.stringify(path)}.` };
-        }
-        return applyAndValidate(
-          tab,
-          (t) => mutateRemoveNode(t, path),
-          `Removed node at ${JSON.stringify(path)}.`,
-          validate,
-          renderCheck,
-          styleOf(),
-        );
-      },
-    }),
-  );
 }

package/src/services/ai-write-report.ts

@@ -0,0 +1,174 @@
+/**
+ * Ai-write-report.ts — what the model is told after a document write, whoever made it.
+ *
+ * Extracted from `ai-tools.ts`'s `applyAndValidate`, which used to own both halves of a document
+ * tool: the transaction and the verdict on it. The verdict is the half every document write needs
+ * — the seven hand-registered tree tools AND every command the assistant runs through
+ * `services/ai-command-tools.ts` — so it lives here, in two functions the caller brackets its write
+ * with:
+ *
+ * 1. {@link snapshotBeforeWrite} reads the document's schema errors and render state BEFORE the
+ *    write, because the eval signal (ADR docs/ai-assistant-decision.md §6b) is "what did this edit
+ *    newly introduce", not "is the document valid": a page that was already broken must not make
+ *    every subsequent edit read as the culprit.
+ * 2. {@link reportDocumentWrite} compares AFTER the write, translating each new schema error into a
+ *    fix hint the model can act on, running the render check only when rendering worked before,
+ *    and appending the soft token-discipline hints to a success.
+ *
+ * The change stays applied either way (optimistic apply + undo, ADR §5); reporting the errors lets
+ * the agent loop self-correct on the next round.
+ *
+ * @license MIT
+ */
+
+import type { ToolResult } from "@jxsuite/ai/tools";
+import { toRaw } from "../reactivity";
+import type { Tab } from "../tabs/tab";
+import { flagHardcodedTokens, formatTokenHints } from "./token-lint";
+
+/** A render probe's answer: rendered, or the message it threw. */
+export type RenderVerdict = { ok: true } | { ok: false; error: string };
+
+/** What a write reporter needs. Every member is what `registerAiTools` already takes by injection. */
+export interface WriteReportDeps {
+  /** Schema errors for a document, as raw ajv sentences. */
+  validate: (doc: unknown) => Promise<string[]>;
+  /** The detached-DOM render probe, when the host has one. */
+  renderCheck?: ((doc: unknown) => Promise<RenderVerdict>) | undefined;
+  /** The project's design tokens, read per call so a project opened mid-session contributes. */
+  getProjectStyle?: (() => Record<string, string> | undefined) | undefined;
+}
+
+/** The document as it stood before a write, in the two respects the verdict compares. */
+export interface WriteSnapshot {
+  errors: Set<string>;
+  renderOk: boolean;
+}
+
+/**
+ * Translate a raw JSON Schema validation error into a Jx-specific actionable message. The LLM needs
+ * concrete guidance on HOW to fix errors, not just what rule was violated. Shared with the
+ * project-level file tools (ai-project-tools.ts), which pre-validate Jx documents before writing.
+ *
+ * @param {string} rawError - Message from ajv (e.g. "/children/0/style: must NOT have additional
+ *   property")
+ * @returns {string}
+ */
+export function translateValidationError(rawError: string): string {
+  const lower = rawError.toLowerCase();
+
+  // Additional property — extract the offending key from the message if present
+  if (
+    lower.includes("must not have additional property") ||
+    lower.includes("additional properties")
+  ) {
+    return `${rawError}\n  → Fix: Remove or move the unexpected property. Style properties must be camelCase (e.g. "backgroundColor", not "background-color"). Non-IDL HTML attributes (aria-*, data-*, role, ...) must go inside an "attributes" object: { "attributes": { "aria-label": "..." } }.`;
+  }
+
+  // Pattern — usually tagName hyphen rule
+  if (lower.includes("must match pattern")) {
+    return `${rawError}\n  → Fix: Custom element tag names must contain a hyphen (e.g. "newsletter-form", "feature-card"). Standard HTML elements use their exact name (e.g. "div", "input", "button").`;
+  }
+
+  // Type error
+  if (lower.includes("must be string")) {
+    return `${rawError}\n  → Fix: Wrap the value in quotes — all Jx property values should be strings. For example, use "10px" (string) not 10px (unquoted).`;
+  }
+
+  if (lower.includes("must be number") || lower.includes("must be integer")) {
+    return `${rawError}\n  → Fix: Remove quotes from the numeric value — it should be a plain number, not a string.`;
+  }
+
+  if (lower.includes("must be object") || lower.includes("must be array")) {
+    return `${rawError}\n  → Fix: The value must be an object/array (use {} or []), not a string or number.`;
+  }
+
+  if (lower.includes("must be boolean")) {
+    return `${rawError}\n  → Fix: Use true or false without quotes for boolean values.`;
+  }
+
+  // Required property
+  if (lower.includes("must have required property")) {
+    return `${rawError}\n  → Fix: Add the missing required property. Every Jx element must have at least a "tagName" field.`;
+  }
+
+  // Enum / allowed values
+  if (lower.includes("must be equal to one of the allowed values")) {
+    return `${rawError}\n  → Fix: Change the value to one of the allowed options listed in the error.`;
+  }
+
+  return rawError;
+}
+
+/**
+ * Read the document's standing BEFORE a write: its schema errors and whether it renders.
+ *
+ * Reads the RAW document, not the reactive proxy, for the same reason `applyAndValidate` always
+ * did: the validator walks the whole tree, and walking a proxy subscribes whichever effect is
+ * running to every key of it.
+ *
+ * @param {Tab} tab
+ * @param {WriteReportDeps} deps
+ * @returns {Promise<WriteSnapshot>}
+ */
+export async function snapshotBeforeWrite(tab: Tab, deps: WriteReportDeps): Promise<WriteSnapshot> {
+  const rawBefore = toRaw(tab.doc.document);
+  const errors = new Set(await deps.validate(rawBefore));
+  const rendered = deps.renderCheck ? await deps.renderCheck(rawBefore) : { ok: true };
+  return { errors, renderOk: rendered.ok };
+}
+
+/**
+ * The verdict on a write that has been applied: the NEW schema errors with fix hints, the render
+ * check (only when rendering worked before — a page that already failed to render is not this
+ * edit's fault), or a success carrying `summary` plus any token-discipline hints.
+ *
+ * The three sentences here are the ones the model has read since the tools were written; every
+ * bridged document command now answers with the same ones, which is what lets the prompt's error
+ * recovery guidance stay generic.
+ *
+ * @param {Tab} tab
+ * @param {WriteSnapshot} before - What {@link snapshotBeforeWrite} read.
+ * @param {string} summary - The sentence to return on success.
+ * @param {WriteReportDeps} deps
+ * @returns {Promise<ToolResult>}
+ */
+export async function reportDocumentWrite(
+  tab: Tab,
+  before: WriteSnapshot,
+  summary: string,
+  deps: WriteReportDeps,
+): Promise<ToolResult> {
+  const rawAfter = toRaw(tab.doc.document);
+  const after = await deps.validate(rawAfter);
+  const newErrors = after.filter((e) => !before.errors.has(e));
+  if (newErrors.length > 0) {
+    const formatted = newErrors.map((e) => `- ${translateValidationError(e)}`).join("\n");
+    return {
+      success: false,
+      error: `Change applied, but it introduced schema errors. Fix these issues with follow-up edits:\n${formatted}`,
+    };
+  }
+
+  if (deps.renderCheck && before.renderOk) {
+    const renderResult = await deps.renderCheck(rawAfter);
+    if (!renderResult.ok) {
+      return {
+        success: false,
+        error: `Change applied and schema-valid, but it broke rendering. Fix with follow-up edits:\n- ${renderResult.error}`,
+      };
+    }
+  }
+
+  // Soft token-discipline hints (never fail the mutation)
+  const projectStyle = deps.getProjectStyle?.();
+  if (projectStyle) {
+    const findings = flagHardcodedTokens(rawAfter, projectStyle);
+    const hints = formatTokenHints(findings);
+    if (hints) {
+      return { success: true, summary: `${summary}\n\n${hints}` };
+    }
+  }
+
+  return { success: true, summary };
+}

package/src/services/context-manager.ts

@@ -12,6 +12,7 @@
  */
 
 import type { createChatState } from "@jxsuite/ai/chat-state";
+import { modelContextWindow } from "./ai-models";
 
 /** Shape of a single entry returned by `chatState.toMessagesArray()`. */
 interface MessageArrayEntry {
@@ -52,7 +53,13 @@ const BUDGET_FRACTION = 0.8;
 const WARN_FRACTION = 0.5;
 
 /**
- * Resolve the context window (tokens) for a model id via longest-prefix match.
+ * Resolve the context window (tokens) for a model id: what the backend reported, else a
+ * longest-prefix match on the table above, else the conservative default.
+ *
+ * The backend's number goes first because the table can only ever know the names it was written
+ * with. Every `@cf/*` model missed it and was budgeted at {@link DEFAULT_CONTEXT_WINDOW}, so a
+ * managed 128k model started dropping the oldest turns at about 25.6k — a fifth of what it could
+ * hold, on the one backend that actually publishes the figure.
  *
  * @param {string | undefined} model
  * @returns {number}
@@ -61,6 +68,10 @@ function contextWindowFor(model: string | undefined): number {
   if (!model) {
     return DEFAULT_CONTEXT_WINDOW;
   }
+  const reported = modelContextWindow(model);
+  if (reported !== undefined && reported > 0) {
+    return reported;
+  }
   const id = model.toLowerCase();
   let best = 0;
   let window = DEFAULT_CONTEXT_WINDOW;

package/src/services/document-assistant.ts

@@ -21,6 +21,11 @@ import { componentRegistry } from "../files/components";
 import { activeRegistry } from "../commands/active-registry";
 import { registerAiTools } from "./ai-tools";
 import { cancelAsk, registerAskTool, resetAsk } from "./ai-ask";
+import {
+  commandToolBlurbs,
+  composeToolRegistries,
+  createCommandToolRegistry,
+} from "./ai-command-tools";
 import { registerProjectTools } from "./ai-project-tools";
 import { registerImportTools, resetImportGuard } from "./ai-import-tools";
 import { createGatedToolRegistry } from "./gated-registry";
@@ -29,12 +34,14 @@ import { adoptProject } from "./project-adoption";
 import { abortImportRun, resetImportRuns } from "./import-run";
 import { runAgentLoop } from "./tool-executor";
 import { AI_TOOL_TIERS, buildSystemPrompt, toolActive } from "./ai-system-prompt";
+import type { ExtensionCatalogSummary } from "./ai-system-prompt";
 import { getBaseUrl, getOpenAiKey } from "./ai-settings";
 import { preferredModel } from "./ai-models";
 import { pruneOrphanToolMessages, trimContext } from "./context-manager";
 import { renderCheck } from "./render-critic";
+import { validateDoc } from "./jx-validate";
 import { openFileInTab, reloadFileInTab } from "../files/files";
-import { refreshExtensionUi } from "../format/format-host";
+import { getExtensionCatalog, refreshExtensionUi } from "../format/format-host";
 import * as sessionStore from "./ai-session-store";
 
 /**
@@ -189,7 +196,26 @@ export function createDocumentAssistant() {
       },
     ]),
   );
-  const toolRegistry = createGatedToolRegistry(innerRegistry, availability);
+  /*
+   * The other kind of tool: every command record that declares `aiTool`, as a VIEW over the active
+   * registry (`services/ai-command-tools.ts`). Nothing is registered — the record IS the tool, its
+   * `when` / `enablement` is the gate, `registry.run` is the executor — so `enable_extension`,
+   * `delete_node` and the rest need no row in the tier table and no registrar here. The deps are
+   * the write reporter's, the same three the hand tree tools take, because a bridged document write
+   * is held to the same verdict (new schema errors, the render check, the token hints).
+   */
+  const commandTools = createCommandToolRegistry({
+    getProjectStyle,
+    getTab: () => activeTab.value,
+    renderCheck: renderCheck as (
+      doc: unknown,
+    ) => Promise<{ ok: true } | { ok: false; error: string }>,
+    validate: validateDoc,
+  });
+  const toolRegistry = composeToolRegistries(
+    createGatedToolRegistry(innerRegistry, availability),
+    commandTools,
+  );
 
   let controller: AbortController | null = null;
 
@@ -201,6 +227,19 @@ export function createDocumentAssistant() {
           .filter((e) => e.type === "file")
           .map((e) => e.path)
       : undefined;
+    /* The synchronous snapshot beside the async load, exactly as `getExtensions()` sits beside
+       `loadExtensions()`: `buildSystemPrompt` is a pure function and this is called per turn, so
+       the catalogue is read from the ONE cache the Extensions section also reads. Two caches would
+       be two answers to "what can this project turn on". */
+    const catalog: ExtensionCatalogSummary[] = [];
+    for (const entry of getExtensionCatalog()) {
+      catalog.push({
+        name: entry.name,
+        sections: entry.sections.map((section) => section.key),
+        ...(entry.title === undefined ? {} : { title: entry.title }),
+        ...(entry.description === undefined ? {} : { description: entry.description }),
+      });
+    }
     return buildSystemPrompt({
       document: tab ? toRaw(tab.doc.document) : undefined,
       projectConfig: (workspace.projectConfig as ProjectConfig | null) || undefined,
@@ -208,7 +247,16 @@ export function createDocumentAssistant() {
       projectRoot: workspace.projectRoot || undefined,
       hasProject: Boolean(workspace.projectRoot),
       canImport: Boolean(getPlatform().importSite),
+      /* The same reading the gate makes, so the prompt advertises exactly what `execute` will
+         honour. This was never passed: with Project Settings focused the prompt listed the seven
+         hand tree writers while the `document-tree` gate refused every one of them, and the model
+         spent a round learning it. */
+      treeEditable: treeEditable(),
+      /* Read per turn from the live registry — a projected tool the gate will honour this round is
+         listed this round, and one it will not is not. */
+      commandTools: commandToolBlurbs(activeRegistry()),
       ...(inventory && inventory.length > 0 ? { fileInventory: inventory } : {}),
+      ...(catalog.length > 0 ? { extensionCatalog: catalog } : {}),
     });
   }
 

package/src/services/idle.ts

@@ -12,22 +12,29 @@
  * in-flight (gitStatus)"]` — so the slow subsystem identifies itself.
  *
  * Nothing here polls a subsystem it does not own. Each source is a function the owning module
- * already had to write for its own reasons:
+ * already had to write for its own reasons.
+ *
+ * There WAS a seventh, `panel-scheduler.pendingSchedulers()`, and it went with the scheduler. It
+ * reported a panel with an animation frame queued or a render withheld while a field had focus —
+ * both facts about a lit dock repainting itself. The Navigator and the Inspector are documents now
+ * (`surfaces/navigator-dock.json`, `surfaces/inspector-dock.json`): a projection is written
+ * synchronously and a binding whose value did not move writes nothing, so there is no queued frame
+ * to be outstanding and no withheld render to wait for. The panel bodies that ARE still lit are
+ * painted synchronously from the same call.
  *
  * 1. `store.rendersInFlight()` — renderers mid-paint.
- * 2. `panel-scheduler.pendingSchedulers()` — panels with a frame queued or a render withheld.
- * 3. `iframe-host.canvasIdleBlockers()` — per host: unacked generations and patches, plus the frame's
+ * 2. `iframe-host.canvasIdleBlockers()` — per host: unacked generations and patches, plus the frame's
  *    own cross-realm report of fonts, running animations and pending image retries.
- * 4. `platform.platformInFlight()` — unsettled PAL calls, counted at the one seam every adapter and
+ * 3. `platform.platformInFlight()` — unsettled PAL calls, counted at the one seam every adapter and
  *    all thirty-odd `git*`/fs/fetch methods pass through.
- * 5. `layers.overlayIdleBlockers()` — overlays still in transition. Only the SETTLING window counts: a
+ * 4. `layers.overlayIdleBlockers()` — overlays still in transition. Only the SETTLING window counts: a
  *    resting toast is not a blocker, which is what lets `toastsAreHeld()` hold one open for a
  *    capture without `probeIdle()` waiting forever alongside it (plan §13.7's named exception).
- * 6. `activity-panel.activityIdleBlockers()` — operations still RUNNING in the Activity tab. Not a
+ * 5. `activity-panel.activityIdleBlockers()` — operations still RUNNING in the Activity tab. Not a
  *    duplicate of `platform`: an activity spans a whole operation (an install, a deploy, a clone)
  *    across many PAL calls, so the gaps between them look quiet at the seam while the operation is
  *    plainly mid-flight. A finished entry never blocks — the list stays on screen forever.
- * 7. `grid-idle.gridIdleBlockers()` — tables still building, or built but not yet showing the
+ * 6. `grid-idle.gridIdleBlockers()` — tables still building, or built but not yet showing the
  *    selection range `selectableRange: 1` gives them. Nothing else covered Tabulator: a grid
  *    command resolves when the panel mounts, which is several frames before the table is drawn.
  *
@@ -37,7 +44,6 @@
 
 import { rendersInFlight } from "../store";
 import { activityIdleBlockers } from "../panels/activity-panel";
-import { pendingSchedulers } from "../panels/panel-scheduler";
 import { canvasIdleBlockers } from "../canvas/iframe-host";
 import { platformInFlight } from "../platform";
 import { overlayIdleBlockers } from "../ui/layers";
@@ -45,7 +51,7 @@ import { gridIdleBlockers } from "../grid/grid-idle";
 
 /** One subsystem that can be outstanding, and its account of why. */
 export interface IdleSource {
-  /** Stable name — `render`, `panels`, `canvas`, `platform`, `overlay`. */
+  /** Stable name — `render`, `canvas`, `platform`, `overlay`. */
   readonly name: string;
   /** Empty when quiet; otherwise one human-readable line per outstanding item. */
   blockers: () => readonly string[];
@@ -73,7 +79,7 @@ export class NotIdleError extends Error {
 }
 
 /**
- * The seven live sources.
+ * The six live sources.
  *
  * Built per call rather than held in a module constant so a test can substitute one without
  * unpicking the others, and so a second window's hosts are never read through the first window's
@@ -88,10 +94,6 @@ export function defaultIdleSources(): IdleSource[] {
       },
       name: "render",
     },
-    {
-      blockers: () => pendingSchedulers().map((panel) => `panels: ${panel}`),
-      name: "panels",
-    },
     { blockers: canvasIdleBlockers, name: "canvas" },
     {
       blockers: () => {