collabmd 0.1.49 → 0.1.51

package/src/domain/agent-tool-definitions.js

@@ -8,12 +8,6 @@ const REVISION_SCHEMA = {
   type: 'string',
 };
 
-const DOCUMENT_SCHEMA = objectSchema({
-  kind: { type: 'string' },
-  mtimeMs: { minimum: 0, type: 'number' },
-  path: { type: 'string' },
-  size: { minimum: 0, type: 'number' },
-});
 const WORKSPACE_ENTRY_SCHEMA = objectSchema({
   agentEditable: { type: 'boolean' },
   embeddable: { type: 'boolean' },
@@ -208,6 +202,12 @@ const EXCALIDRAW_SUMMARY_ELEMENT_SCHEMA = {
     },
     endElementId: { type: 'string' },
     containerId: { type: 'string' },
+    fontFamily: {
+      description: 'Excalidraw font-family identifier. Standard Excalifont is 5; legacy Virgil is 1.',
+      minimum: 1,
+      type: 'integer',
+    },
+    fontName: { type: 'string' },
     fontSize: { exclusiveMinimum: 0, type: 'number' },
     height: { minimum: 0, type: 'number' },
     id: { type: 'string' },
@@ -242,7 +242,16 @@ const EXCALIDRAW_INSPECTION_PROPERTIES = {
   bounds: EXCALIDRAW_BOUNDS_SCHEMA,
   elementCount: { minimum: 0, type: 'integer' },
   elements: { items: EXCALIDRAW_SUMMARY_ELEMENT_SCHEMA, type: 'array' },
+  layout: objectSchema({
+    boundText: objectSchema({
+      misaligned: { minimum: 0, type: 'integer' },
+      outsideContainer: { minimum: 0, type: 'integer' },
+      staleHeight: { minimum: 0, type: 'integer' },
+      total: { minimum: 0, type: 'integer' },
+    }),
+  }),
   truncated: { type: 'boolean' },
+  valid: { type: 'boolean' },
   warnings: { items: EXCALIDRAW_WARNING_SCHEMA, type: 'array' },
 };
 const EXCALIDRAW_INSPECTION_SCHEMA = objectSchema(EXCALIDRAW_INSPECTION_PROPERTIES);
@@ -262,11 +271,6 @@ const EXCALIDRAW_RENDER_RESULT_PROPERTIES = {
   warnings: { items: { type: 'string' }, type: 'array' },
   width: { minimum: 1, type: 'integer' },
 };
-const EXCALIDRAW_RENDER_OUTPUT_PROPERTIES = {
-  ...EXCALIDRAW_RENDER_RESULT_PROPERTIES,
-  path: { type: 'string' },
-  revision: REVISION_SCHEMA,
-};
 const EXCALIDRAW_RENDER_INPUT_PROPERTIES = {
   format: {
     description: 'Image format. PNG is most widely supported by MCP clients.',
@@ -285,6 +289,10 @@ const EXCALIDRAW_RENDER_INPUT_PROPERTIES = {
     minLength: 1,
     type: 'string',
   },
+  render: {
+    description: 'Return an image render. Set false for a compact structural and layout verification response.',
+    type: 'boolean',
+  },
   scale: {
     description: 'Requested output scale; automatically reduced when needed to stay within 4096 pixels.',
     maximum: 4,
@@ -309,11 +317,29 @@ const EXCALIDRAW_INLINE_VERIFICATION_SCHEMA = objectSchema({
   inspection: EXCALIDRAW_INSPECTION_SCHEMA,
   ...EXCALIDRAW_RENDER_RESULT_PROPERTIES,
 }, ['inspection']);
+const EXCALIDRAW_COMPACT_VERIFICATION_PROPERTIES = {
+  elementCount: { minimum: 0, type: 'integer' },
+  format: { enum: ['png', 'svg'], type: 'string' },
+  inspection: EXCALIDRAW_INSPECTION_SCHEMA,
+  layout: EXCALIDRAW_INSPECTION_PROPERTIES.layout,
+  path: { type: 'string' },
+  revision: REVISION_SCHEMA,
+  valid: { type: 'boolean' },
+};
+const EXCALIDRAW_VERIFY_OUTPUT_SCHEMA = {
+  oneOf: [
+    objectSchema(EXCALIDRAW_COMPACT_VERIFICATION_PROPERTIES),
+    objectSchema({
+      ...EXCALIDRAW_COMPACT_VERIFICATION_PROPERTIES,
+      ...EXCALIDRAW_RENDER_RESULT_PROPERTIES,
+    }),
+  ],
+};
 
 export const AGENT_TOOL_DEFINITIONS = Object.freeze([
   {
     annotations: { idempotentHint: true, readOnlyHint: true },
-    description: 'List readable CollabMD Vault documents by path and kind.',
+    description: 'List current Vault files and directories, including binary metadata and agent capability flags.',
     inputSchema: objectSchema({
       cursor: {
         description: 'Path from the previous nextCursor; omit for the first page.',
@@ -326,7 +352,7 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
         uniqueItems: true,
       },
       limit: {
-        description: 'Maximum documents to return.',
+        description: 'Maximum entries to return.',
         maximum: 200,
         minimum: 1,
         type: 'integer',
@@ -335,34 +361,10 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
         description: 'Optional Vault directory or path prefix.',
         type: 'string',
       },
-    }, []),
-    method: 'listDocuments',
-    name: 'list_documents',
-    outputSchema: objectSchema({
-      documents: { items: DOCUMENT_SCHEMA, type: 'array' },
-      nextCursor: { type: ['string', 'null'] },
-      truncated: { type: 'boolean' },
-    }),
-    scope: 'vault:read',
-    untrustedContentHint: true,
-    webMcp: true,
-  },
-  {
-    annotations: { idempotentHint: true, readOnlyHint: true },
-    description: 'List current Vault files and directories, including binary metadata and agent capability flags.',
-    inputSchema: objectSchema({
-      cursor: {
-        description: 'Path from the previous nextCursor; omit for the first page.',
-        type: 'string',
-      },
-      limit: {
-        description: 'Maximum entries to return.',
-        maximum: 200,
-        minimum: 1,
-        type: 'integer',
-      },
-      prefix: {
-        description: 'Optional Vault directory or path prefix.',
+      pathQuery: {
+        description: 'Optional case-insensitive substring to match anywhere in an entry path.',
+        maxLength: 500,
+        minLength: 1,
         type: 'string',
       },
     }, []),
@@ -388,12 +390,32 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
         minimum: 1,
         type: 'integer',
       },
+      maxSnippetsPerFile: {
+        description: 'Maximum matching snippets returned per document.',
+        maximum: 10,
+        minimum: 1,
+        type: 'integer',
+      },
+      kinds: {
+        description: 'Optional CollabMD content kinds to include.',
+        items: { type: 'string' },
+        type: 'array',
+        uniqueItems: true,
+      },
+      prefix: {
+        description: 'Optional Vault directory or path prefix.',
+        type: 'string',
+      },
       query: {
         description: 'Literal case-insensitive text to find; regular expressions are not supported.',
         maxLength: 500,
         minLength: 2,
         type: 'string',
       },
+      wholeWord: {
+        description: 'Match only when the literal query is bounded by non-word characters.',
+        type: 'boolean',
+      },
     }, ['query']),
     method: 'searchVault',
     name: 'search_vault',
@@ -507,6 +529,65 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
     untrustedContentHint: true,
     webMcp: true,
   },
+  {
+    annotations: { idempotentHint: true, readOnlyHint: true },
+    description: 'Run a Base query and return filtered rows so you can verify filters and expected output.',
+    inputSchema: objectSchema({
+      limit: {
+        description: 'Maximum rows to return.',
+        maximum: 200,
+        minimum: 1,
+        type: 'integer',
+      },
+      path: {
+        description: 'Vault-relative .base path.',
+        maxLength: 1024,
+        minLength: 1,
+        type: 'string',
+      },
+      search: {
+        description: 'Optional case-insensitive row search across visible columns.',
+        maxLength: 500,
+        type: 'string',
+      },
+      view: {
+        description: 'Optional Base view name.',
+        maxLength: 200,
+        type: 'string',
+      },
+    }, ['path']),
+    method: 'queryBase',
+    name: 'query_base',
+    outputSchema: objectSchema({
+      columns: {
+        items: objectSchema({
+          id: { type: 'string' },
+          label: { type: 'string' },
+        }),
+        type: 'array',
+      },
+      path: { type: 'string' },
+      rows: {
+        items: objectSchema({
+          cells: {
+            additionalProperties: { type: 'string' },
+            type: 'object',
+          },
+          path: { type: 'string' },
+        }),
+        type: 'array',
+      },
+      totalRows: { minimum: 0, type: 'integer' },
+      truncated: { type: 'boolean' },
+      view: objectSchema({
+        name: { type: 'string' },
+        type: { type: 'string' },
+      }),
+    }),
+    scope: 'vault:read',
+    untrustedContentHint: true,
+    webMcp: true,
+  },
   {
     annotations: { idempotentHint: true, readOnlyHint: true },
     description: 'Render one standalone or fenced Mermaid/PlantUML diagram. Markdown with multiple diagrams requires the opening fence startLine. Mermaid rendering requires WebMCP.',
@@ -539,7 +620,7 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
 
   {
     annotations: { idempotentHint: true, readOnlyHint: true },
-    description: 'Inspect an Excalidraw scene structurally. Returns paint order, geometry, bindings, bounds, occlusion, clipping, and validity warnings.',
+    description: 'Inspect an Excalidraw scene structurally. Returns paint order, geometry, text style, bindings, bounds, layout diagnostics, occlusion, clipping, and validity warnings.',
     inputSchema: objectSchema({
       path: {
         description: 'Vault-relative .excalidraw path.',
@@ -557,19 +638,7 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
   },
   {
     annotations: { idempotentHint: true, readOnlyHint: true },
-    description: 'Render supported basic elements as PNG or SVG. Returns renderer metadata and warns when preview is not pixel-identical to Excalidraw.',
-    inputSchema: objectSchema(EXCALIDRAW_RENDER_INPUT_PROPERTIES, ['path']),
-    method: 'renderExcalidraw',
-    name: 'render_excalidraw',
-    outputSchema: objectSchema(EXCALIDRAW_RENDER_OUTPUT_PROPERTIES),
-    resultKind: 'image',
-    scope: 'vault:read',
-    untrustedContentHint: true,
-    webMcp: true,
-  },
-  {
-    annotations: { idempotentHint: true, readOnlyHint: true },
-    description: 'Inspect and render one Excalidraw revision in a single operation.',
+    description: 'Verify one Excalidraw revision with compact structural and layout diagnostics; render is optional.',
     inputSchema: objectSchema({
       ...EXCALIDRAW_RENDER_INPUT_PROPERTIES,
       inspectOcclusion: {
@@ -579,11 +648,8 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
     }, ['path']),
     method: 'verifyExcalidraw',
     name: 'verify_excalidraw',
-    outputSchema: objectSchema({
-      ...EXCALIDRAW_RENDER_OUTPUT_PROPERTIES,
-      inspection: EXCALIDRAW_INSPECTION_SCHEMA,
-    }),
-    resultKind: 'image',
+    outputSchema: EXCALIDRAW_VERIFY_OUTPUT_SCHEMA,
+    resultKind: 'optional-image',
     scope: 'vault:read',
     untrustedContentHint: true,
     webMcp: true,
@@ -634,14 +700,14 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
       path: { type: 'string' },
       revision: REVISION_SCHEMA,
       verification: EXCALIDRAW_INLINE_VERIFICATION_SCHEMA,
-    }),
+    }, ['elementCount', 'path', 'revision']),
     resultKind: 'optional-image',
     scope: 'vault:edit',
     webMcp: true,
   },
   {
     annotations: { destructiveHint: false, idempotentHint: false, readOnlyHint: false },
-    description: 'Create, update, replace, translate, reorder, or delete elements in an existing .excalidraw scene when its revision still matches.',
+    description: 'Create, update, replace, translate, reorder, or delete elements in an existing .excalidraw scene when its revision still matches. Bound text whose font, size, line height, or content changes reflows automatically.',
     inputSchema: objectSchema({
       create: {
         items: EXCALIDRAW_ELEMENT_INPUT_SCHEMA,
@@ -655,6 +721,11 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
         type: 'array',
         uniqueItems: true,
       },
+      normalizeTextPlacement: {
+        description: 'Normalize every bound text label to its container center and current line-height metrics. This can be the only edit operation.',
+        enum: [true],
+        type: 'boolean',
+      },
       path: {
         description: 'Vault-relative .excalidraw path returned by read_document.',
         maxLength: 1024,
@@ -690,6 +761,11 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
       elementCount: { minimum: 0, type: 'integer' },
       path: { type: 'string' },
       reordered: { minimum: 0, type: 'integer' },
+      reflowed: {
+        description: 'Number of bound text labels whose position or height was normalized.',
+        minimum: 0,
+        type: 'integer',
+      },
       replaced: { minimum: 0, type: 'integer' },
       revision: REVISION_SCHEMA,
       translated: {
@@ -699,7 +775,7 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
       },
       updated: { minimum: 0, type: 'integer' },
       verification: EXCALIDRAW_INLINE_VERIFICATION_SCHEMA,
-    }, ['created', 'deleted', 'elementCount', 'path', 'reordered', 'replaced', 'revision', 'translated', 'updated']),
+    }, ['created', 'deleted', 'elementCount', 'path', 'reordered', 'reflowed', 'replaced', 'revision', 'translated', 'updated']),
     resultKind: 'optional-image',
     scope: 'vault:edit',
     webMcp: true,

package/src/domain/collabmd-content-capabilities.js

@@ -15,11 +15,11 @@ import {
 
 const CAPABILITIES = Object.freeze({
   base: {
-    agentCreatable: false,
-    agentEditable: false,
+    agentCreatable: true,
+    agentEditable: true,
     editable: true,
     extensions: [BASE_FILE_EXTENSION],
-    guide: 'YAML Base definition. Embed a file with ![[query.base]] or an inline query with a fenced base block. Agent writes are disabled until Base validation is shared.',
+    guide: 'YAML Base definition. Embed a file with ![[query.base]] or an inline query with a fenced base block. Create and edit with create_document and apply_text_edits. After writing, use query_base to inspect filtered rows.',
     examples: ['```base\nfilters:\n  and: []\n```', '![[tasks.base]]'],
   },
   drawio: {
@@ -35,7 +35,7 @@ const CAPABILITIES = Object.freeze({
     agentEditable: true,
     editable: true,
     extensions: [EXCALIDRAW_FILE_EXTENSION],
-    guide: 'Excalidraw scene JSON managed by the canvas editor. Use create_excalidraw and edit_excalidraw rather than raw text edits. Element order is back-to-front; create supports beforeElementId and afterElementId, while edit supports relationship-aware translation, reorder, same-ID replace, and same-revision verification. Container or group translation also moves bound text and grouped members. Standalone auto-resizing text recalculates its bounds when text metrics change. Line, arrow, and freedraw dimensions are derived from points. Creation and editing support inline inspection and optional rendering; remote fallback renders report preview-not-pixel-identical. Supported agent element types: rectangle, ellipse, diamond, text, arrow, line, and freedraw. Embed with ![[drawing.excalidraw]].',
+    guide: 'Excalidraw scene JSON managed by the canvas editor. Use create_excalidraw and edit_excalidraw rather than raw text edits. Element order is back-to-front; create supports beforeElementId and afterElementId, while edit supports relationship-aware translation, reorder, same-ID verification, and bound-text placement normalization. Container or group translation also moves bound text and grouped members. Standalone auto-resizing text recalculates its bounds when text metrics change; bound text whose font, size, line height, or content changes is re-centered and remeasured vertically. Line, arrow, and freedraw dimensions are derived from points. Creation and editing support inline inspection and optional rendering; verify_excalidraw can return compact layout diagnostics without an image. Remote fallback renders report preview-not-pixel-identical. Supported agent element types: rectangle, ellipse, diamond, text, arrow, line, and freedraw. Embed with ![[drawing.excalidraw]].',
     examples: ['![[drawing.excalidraw]]'],
   },
   html: {

package/src/domain/excalidraw-agent-scene.js

@@ -14,6 +14,18 @@ const ELEMENT_TYPES = new Set([
 ]);
 
 const LINEAR_TYPES = new Set(['arrow', 'freedraw', 'line']);
+// Matches Excalidraw's DEFAULT_FONT_FAMILY (Excalifont).
+const DEFAULT_TEXT_FONT_FAMILY = 5;
+const TEXT_LAYOUT_CONTAINER_TYPES = new Set(['diamond', 'ellipse', 'rectangle']);
+const TEXT_METRIC_FIELDS = new Set([
+  'autoResize',
+  'containerId',
+  'fontFamily',
+  'fontSize',
+  'lineHeight',
+  'text',
+]);
+const TEXT_GEOMETRY_FIELDS = new Set(['height', 'width', 'x', 'y']);
 
 function invalid(message) {
   const error = new Error(message);
@@ -186,7 +198,7 @@ function addFreeDrawElementFields(element, raw) {
 function addTextElementFields(element, raw, { fontSize, text }) {
   element.autoResize = raw.autoResize ?? true;
   element.containerId = raw.containerId ?? null;
-  element.fontFamily = raw.fontFamily ?? 1;
+  element.fontFamily = raw.fontFamily ?? DEFAULT_TEXT_FONT_FAMILY;
   element.fontSize = fontSize;
   element.lineHeight = raw.lineHeight ?? 1.25;
   element.originalText = raw.originalText ?? text;
@@ -341,6 +353,66 @@ function resolveTranslationIds(elements, requestedIds) {
   return [...resolved];
 }
 
+function textHeight(element) {
+  const text = String(element.text ?? '');
+  const lineCount = Math.max(1, text.split('\n').length);
+  const fontSize = requireNumber(element.fontSize ?? 20, `Element ${element.id} fontSize`);
+  const lineHeight = requireNumber(element.lineHeight ?? 1.25, `Element ${element.id} lineHeight`);
+  return lineCount * fontSize * lineHeight;
+}
+
+function sameNumber(left, right) {
+  return Math.abs(left - right) < 0.001;
+}
+
+function reflowBoundText(elements, ids, now, alreadyVersionedIds) {
+  const activeById = new Map(
+    elements.filter((element) => !element.isDeleted).map((element) => [element.id, element]),
+  );
+  let reflowed = 0;
+
+  ids.forEach((id) => {
+    const text = activeById.get(id);
+    if (text?.type !== 'text' || !text.containerId) return;
+
+    const container = activeById.get(text.containerId);
+    if (
+      !container
+      || !TEXT_LAYOUT_CONTAINER_TYPES.has(container.type)
+      || Number(container.angle ?? 0) !== 0
+    ) {
+      return;
+    }
+
+    const width = requireNumber(text.width, `Element ${id} width`);
+    const height = textHeight(text);
+    const x = requireNumber(container.x, `Element ${text.containerId} x`)
+      + ((requireNumber(container.width, `Element ${text.containerId} width`) - width) / 2);
+    const y = requireNumber(container.y, `Element ${text.containerId} y`)
+      + ((requireNumber(container.height, `Element ${text.containerId} height`) - height) / 2);
+
+    if (
+      sameNumber(text.x, x)
+      && sameNumber(text.y, y)
+      && sameNumber(text.height, height)
+    ) {
+      return;
+    }
+
+    const positioned = { ...text, height, x, y };
+    const next = alreadyVersionedIds.has(id)
+      ? positioned
+      : bumpElementVersion(positioned, now, 'bound-text-layout');
+    const elementIndex = elements.indexOf(text);
+    elements[elementIndex] = next;
+    activeById.set(id, next);
+    alreadyVersionedIds.add(id);
+    reflowed += 1;
+  });
+
+  return reflowed;
+}
+
 export function createAgentExcalidrawScene(rawElements) {
   if (!Array.isArray(rawElements) || rawElements.length < 1 || rawElements.length > 200) {
     throw invalid('Excalidraw scene must contain 1 to 200 elements');
@@ -372,6 +444,10 @@ export function createAgentExcalidrawScene(rawElements) {
 }
 
 export function applyAgentExcalidrawEdits(scene, edits = {}) {
+  return applyAgentExcalidrawEditsWithSummary(scene, edits).scene;
+}
+
+export function applyAgentExcalidrawEditsWithSummary(scene, edits = {}) {
   requireObject(scene, 'Excalidraw scene');
   if (scene.type !== 'excalidraw' || !Array.isArray(scene.elements)) {
     throw invalid('Document is not a valid Excalidraw scene');
@@ -383,10 +459,14 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   const remove = edits.delete ?? [];
   const reorder = edits.reorder ?? [];
   const translate = edits.translate ?? null;
+  const normalizeTextPlacement = edits.normalizeTextPlacement;
   const operations = [create, update, replace, remove, reorder];
   if (!operations.every(Array.isArray)) {
     throw invalid('Excalidraw edit operations must be arrays');
   }
+  if (normalizeTextPlacement !== undefined && normalizeTextPlacement !== true) {
+    throw invalid('normalizeTextPlacement must be true when provided');
+  }
   let translatedIds = [];
   let translateDx = 0;
   let translateDy = 0;
@@ -405,7 +485,11 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
       throw invalid('Translate operation must move elements');
     }
   }
-  const operationCount = operations.reduce((count, entries) => count + entries.length, translatedIds.length);
+  const normalizationOperationCount = normalizeTextPlacement ? 1 : 0;
+  const operationCount = operations.reduce(
+    (count, entries) => count + entries.length,
+    translatedIds.length + normalizationOperationCount,
+  );
   if (operationCount < 1) {
     throw invalid('Excalidraw edits must include at least one operation');
   }
@@ -417,6 +501,7 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   let elements = scene.elements.map((element) => ({ ...element }));
   const byId = new Map(elements.map((element) => [element.id, element]));
   const alreadyVersionedIds = new Set();
+  const autoReflowIds = new Set();
   const createdElements = create.map((raw) => {
     const element = normalizeElement(raw, now);
     if (byId.has(element.id)) throw invalid(`Excalidraw element already exists: ${element.id}`);
@@ -447,8 +532,7 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     const resizesStandaloneText = current.type === 'text'
       && !raw.containerId
       && raw.autoResize !== false
-      && ['autoResize', 'fontFamily', 'fontSize', 'lineHeight', 'text']
-        .some((field) => Object.hasOwn(set, field));
+      && [...TEXT_METRIC_FIELDS].some((field) => Object.hasOwn(set, field));
     if (resizesStandaloneText) {
       delete raw.width;
       delete raw.height;
@@ -457,6 +541,12 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     elements[elements.indexOf(current)] = next;
     byId.set(id, next);
     alreadyVersionedIds.add(id);
+    const changesTextMetrics = current.type === 'text'
+      && [...TEXT_METRIC_FIELDS].some((field) => Object.hasOwn(set, field));
+    const changesTextGeometry = [...TEXT_GEOMETRY_FIELDS].some((field) => Object.hasOwn(set, field));
+    if (changesTextMetrics && !changesTextGeometry) {
+      autoReflowIds.add(id);
+    }
   });
   replace.forEach((operation) => {
     requireObject(operation, 'Replace operation');
@@ -481,7 +571,10 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
   });
   if (translatedIds.length > 0) {
     translatedIds = resolveTranslationIds(elements, translatedIds);
-    const expandedOperationCount = operations.reduce((count, entries) => count + entries.length, translatedIds.length);
+    const expandedOperationCount = operations.reduce(
+      (count, entries) => count + entries.length,
+      translatedIds.length + normalizationOperationCount,
+    );
     if (expandedOperationCount > 200) {
       throw invalid('Excalidraw edits cannot exceed 200 operations including related translations');
     }
@@ -515,8 +608,17 @@ export function applyAgentExcalidrawEdits(scene, edits = {}) {
     const id = String(operation.id ?? '').trim();
     moveElement(elements, id, operation, `Reorder ${id}`);
   });
+  const reflowIds = normalizeTextPlacement
+    ? elements
+      .filter((element) => element.type === 'text' && !element.isDeleted && element.containerId)
+      .map((element) => element.id)
+    : [...autoReflowIds];
+  const reflowed = reflowBoundText(elements, reflowIds, now, alreadyVersionedIds);
   validateUniqueIds(elements);
   elements = normalizeElementOrder(elements, now, alreadyVersionedIds);
   refreshArrowBindings(elements);
-  return { ...scene, elements };
+  return {
+    reflowed,
+    scene: { ...scene, elements },
+  };
 }

package/src/domain/excalidraw-agent-verification.js

@@ -5,6 +5,19 @@ const RENDERED_TYPES = new Set([...BASIC_SHAPE_TYPES, ...LINEAR_TYPES, 'text']);
 const MAX_SUMMARY_ELEMENTS = 500;
 const MAX_WARNINGS = 200;
 const MAX_RENDER_DIMENSION = 4096;
+const BOUND_TEXT_CENTER_TOLERANCE = 2;
+
+const FONT_FAMILY_NAMES = new Map([
+  [1, 'Virgil'],
+  [2, 'Helvetica'],
+  [3, 'Cascadia'],
+  [5, 'Excalifont'],
+  [6, 'Nunito'],
+  [7, 'Lilita One'],
+  [8, 'Comic Shanns'],
+  [9, 'Liberation Sans'],
+  [10, 'Assistant'],
+]);
 
 function finiteNumber(value, fallback = 0) {
   const number = Number(value);
@@ -182,6 +195,9 @@ function summarizeElement(element, paintOrder, activeElements) {
   if (elementBehind?.id) summary.inFrontOf = String(elementBehind.id);
   if (element?.type === 'text') summary.text = String(element.text ?? '');
   if (element?.type === 'text') {
+    const fontFamily = finiteNumber(element.fontFamily, 5);
+    summary.fontFamily = fontFamily;
+    summary.fontName = FONT_FAMILY_NAMES.get(fontFamily) ?? `Unknown (${fontFamily})`;
     summary.fontSize = finiteNumber(element.fontSize, 20);
     summary.lineHeight = finiteNumber(element.lineHeight, 1.25);
     if (element.containerId) summary.containerId = String(element.containerId);
@@ -209,6 +225,78 @@ function textOverflowWarning(element, bounds, id) {
     : null;
 }
 
+function expectedTextHeight(element) {
+  const lines = String(element?.text ?? '').split('\n');
+  return Math.max(1, lines.length)
+    * finiteNumber(element?.fontSize, 20)
+    * finiteNumber(element?.lineHeight, 1.25);
+}
+
+function collectBoundTextLayout(elements) {
+  const activeById = new Map(elements.map((element) => [String(element.id), element]));
+  const layout = {
+    boundText: {
+      misaligned: 0,
+      outsideContainer: 0,
+      staleHeight: 0,
+      total: 0,
+    },
+  };
+  const warnings = [];
+
+  elements.forEach((element) => {
+    if (element?.type !== 'text' || !element.containerId) return;
+    const container = activeById.get(String(element.containerId));
+    if (!container || !BASIC_SHAPE_TYPES.has(container.type) || finiteNumber(container.angle) !== 0) {
+      return;
+    }
+    const textBounds = elementBounds(element);
+    const containerBounds = elementBounds(container);
+    if (!textBounds || !containerBounds) return;
+
+    const id = String(element.id ?? '');
+    const containerId = String(container.id ?? '');
+    const textCenterX = textBounds.x + (textBounds.width / 2);
+    const textCenterY = textBounds.y + (textBounds.height / 2);
+    const containerCenterX = containerBounds.x + (containerBounds.width / 2);
+    const containerCenterY = containerBounds.y + (containerBounds.height / 2);
+    const offsetX = textCenterX - containerCenterX;
+    const offsetY = textCenterY - containerCenterY;
+    const centered = Math.abs(offsetX) <= BOUND_TEXT_CENTER_TOLERANCE
+      && Math.abs(offsetY) <= BOUND_TEXT_CENTER_TOLERANCE;
+
+    layout.boundText.total += 1;
+    if (!centered) {
+      layout.boundText.misaligned += 1;
+      warnings.push(warning(
+        'bound-text-not-centered',
+        `Bound text ${id} is offset ${Math.round(offsetX)} horizontally and ${Math.round(offsetY)} vertically from container ${containerId}.`,
+        [id, containerId],
+      ));
+    }
+
+    if (!boxContains(containerBounds, textBounds)) {
+      layout.boundText.outsideContainer += 1;
+      warnings.push(warning(
+        'bound-text-outside-container',
+        `Bound text ${id} extends outside container ${containerId}.`,
+        [id, containerId],
+      ));
+    }
+
+    if (Math.abs(textBounds.height - expectedTextHeight(element)) > BOUND_TEXT_CENTER_TOLERANCE) {
+      layout.boundText.staleHeight += 1;
+      warnings.push(warning(
+        'bound-text-height-stale',
+        `Bound text ${id} has height ${Math.round(textBounds.height)} but its current text metrics require ${Math.round(expectedTextHeight(element))}.`,
+        [id, containerId],
+      ));
+    }
+  });
+
+  return { layout, warnings };
+}
+
 function boundEndpointWarning(element, binding, endpointName, activeById) {
   if (!binding?.elementId || !LINEAR_TYPES.has(element?.type) || !Array.isArray(element.points)) {
     return null;
@@ -336,7 +424,11 @@ export function inspectAgentExcalidrawScene(scene = {}, {
   const activeElements = (Array.isArray(scene?.elements) ? scene.elements : [])
     .filter((element) => element && !element.isDeleted);
   const boxes = activeElements.map(elementBounds).filter(Boolean);
-  const warnings = collectWarnings(activeElements, { inspectOcclusion });
+  const boundTextLayout = collectBoundTextLayout(activeElements);
+  const warnings = [
+    ...collectWarnings(activeElements, { inspectOcclusion }),
+    ...boundTextLayout.warnings,
+  ].slice(0, MAX_WARNINGS);
   return {
     bounds: mergeBounds(boxes),
     elementCount: activeElements.length,
@@ -348,6 +440,8 @@ export function inspectAgentExcalidrawScene(scene = {}, {
     truncated: (!includeElements && activeElements.length > 0)
       || activeElements.length > MAX_SUMMARY_ELEMENTS
       || warnings.length >= MAX_WARNINGS,
+    layout: boundTextLayout.layout,
+    valid: warnings.length === 0,
     warnings,
   };
 }