@atezer/figma-mcp-bridge 1.9.3 → 1.9.5

package/f-mcp-plugin/code.js

@@ -6,7 +6,97 @@
 
 // v1.8.0+: Plugin version reported in WebSocket "ready" handshake.
 // Keep in sync with package.json and src/core/version.ts.
-var FMCP_PLUGIN_VERSION = '1.9.2';
+var FMCP_PLUGIN_VERSION = '1.9.5';
+
+// v1.9.5: Metadata summary builder for returnMode='summary' (screenshotsuz)
+async function buildNodeSummary(node, maxDepth) {
+  var colorUsage = {}; // role → count
+  var textRoleCount = {}; // styleId → { count, samples }
+  var unboundHexCount = 0;
+  var totalNodes = 0;
+
+  function walk(n, depth) {
+    totalNodes++;
+    // Fill bound token tracking
+    if (Array.isArray(n.fills)) {
+      for (var fi = 0; fi < n.fills.length; fi++) {
+        var fl = n.fills[fi];
+        if (fl && fl.visible !== false && fl.type === 'SOLID') {
+          var fbv = n.boundVariables && n.boundVariables.fills;
+          var bound = fbv && (Array.isArray(fbv) ? fbv[fi] : true);
+          if (bound) {
+            var role = (Array.isArray(fbv) ? fbv[fi] : fbv).id || 'unknown';
+            colorUsage[role] = (colorUsage[role] || 0) + 1;
+          } else {
+            unboundHexCount++;
+          }
+        }
+      }
+    }
+    if (n.type === 'TEXT') {
+      var styleId = n.textStyleId || 'inline';
+      if (!textRoleCount[styleId]) textRoleCount[styleId] = { count: 0, samples: [] };
+      textRoleCount[styleId].count++;
+      if (textRoleCount[styleId].samples.length < 3) {
+        textRoleCount[styleId].samples.push(String(n.characters || '').slice(0, 30));
+      }
+    }
+    if (n.children && depth < 3) { // deep walk but capped
+      for (var ci = 0; ci < n.children.length; ci++) walk(n.children[ci], depth + 1);
+    }
+  }
+
+  walk(node, 0);
+
+  function collectSections(n, depth) {
+    if (depth > maxDepth) return null;
+    var s = {
+      name: n.name,
+      type: n.type,
+      size: n.width && n.height ? Math.round(n.width) + 'x' + Math.round(n.height) : null,
+      childrenCount: n.children ? n.children.length : 0,
+    };
+    if (n.children && n.children.length > 0 && depth < maxDepth) {
+      var items = [];
+      for (var i = 0; i < n.children.length && i < 20; i++) {
+        items.push(collectSections(n.children[i], depth + 1));
+      }
+      s.children = items;
+    }
+    return s;
+  }
+
+  // Resolve variable names (best-effort)
+  var dominantColors = [];
+  var colorEntries = Object.keys(colorUsage).map(function (k) { return { role: k, usage: colorUsage[k] }; });
+  colorEntries.sort(function (a, b) { return b.usage - a.usage; });
+  for (var ci2 = 0; ci2 < Math.min(colorEntries.length, 5); ci2++) {
+    dominantColors.push({ variableId: colorEntries[ci2].role, usageCount: colorEntries[ci2].usage, bound: true });
+  }
+  if (unboundHexCount > 0) {
+    dominantColors.push({ variableId: '<hardcoded>', usageCount: unboundHexCount, bound: false });
+  }
+
+  var textRoles = [];
+  var trKeys = Object.keys(textRoleCount);
+  for (var tk = 0; tk < trKeys.length; tk++) {
+    textRoles.push({ styleId: trKeys[tk], count: textRoleCount[trKeys[tk]].count, samples: textRoleCount[trKeys[tk]].samples });
+  }
+
+  return {
+    nodeId: node.id,
+    name: node.name,
+    type: node.type,
+    dimensions: { width: Math.round(node.width || 0), height: Math.round(node.height || 0) },
+    layoutMode: node.layoutMode || 'NONE',
+    childrenCount: node.children ? node.children.length : 0,
+    totalNodes: totalNodes,
+    sections: collectSections(node, 0),
+    dominantColors: dominantColors,
+    textRoles: textRoles.slice(0, 10),
+    hint: "v1.9.5 summary: Metadata ozeti, gorsel yok. Layout karari icin yeter. Pixel dogrulama gerekirse returnMode='file' veya 'regions'.",
+  };
+}
 
 // Console log buffer for figma_get_console_logs (no CDP)
 var __consoleLogBuffer = [];
@@ -2391,6 +2481,9 @@ figma.ui.onmessage = async (msg) => {
       // Pass 2: Promise.all on getMainComponentAsync for all instances in parallel
       // This cuts 100+ node validation from ~60s to ~5s.
 
+      // v1.9.4: detailed param — if true, collect hardcoded samples + overflow + primitive fallbacks.
+      var detailed = msg.detailed === true;
+
       // Iterative tree walk (stack-safe for deep trees up to 10,000+ nodes)
       var metrics = {
         totalNodes: 0,
@@ -2400,11 +2493,33 @@ figma.ui.onmessage = async (msg) => {
         libraryInstanceNodes: 0,
         stylableNodes: 0,
         nodesWithBindings: 0,
+        // v1.9.4: extra coverage metrics
+        boundFills: 0,
+        unboundSolidFills: 0,
+        paddingsTotal: 0,
+        paddingsBound: 0,
+        itemSpacingTotal: 0,
+        itemSpacingBound: 0,
+        radiusTotal: 0,
+        radiusBound: 0,
+        textsTotal: 0,
+        textsWithStyle: 0,
+        textsHardcodedFontSize: 0,
+        textColorsTotal: 0,
+        textColorsBound: 0,
+        strokesTotal: 0,
+        strokesBound: 0,
       };
       var violations = [];
       var maxViolations = 20; // cap to keep response small
       var instanceNodesList = []; // v1.8.2: collect for batch resolve
 
+      // v1.9.4: detailed mode samples (capped small)
+      var hardcodedHexSamples = [];
+      var hardcodedFontSizeSamples = [];
+      var primitiveFallbacks = [];
+      var maxSamples = 8;
+
       var walkStack = [rootNode];
       var visited = 0;
       var maxVisit = 5000; // safety cap
@@ -2479,6 +2594,95 @@ figma.ui.onmessage = async (msg) => {
           }
         }
 
+        // v1.9.4: Granular bind coverage — fills/strokes/paddings/radius/itemSpacing/text
+        // Separate from stylableNodes/nodesWithBindings (which is coarse grained).
+        try {
+          if (Array.isArray(node.fills) && node.type !== 'INSTANCE') {
+            for (var fi = 0; fi < node.fills.length; fi++) {
+              var fl = node.fills[fi];
+              if (fl && fl.visible !== false && fl.type === 'SOLID') {
+                var fbv = node.boundVariables && node.boundVariables.fills;
+                var fillBound = !!(fbv && (Array.isArray(fbv) ? fbv[fi] : true));
+                if (fillBound) metrics.boundFills++;
+                else {
+                  metrics.unboundSolidFills++;
+                  if (detailed && hardcodedHexSamples.length < maxSamples) {
+                    var c = fl.color;
+                    var hex = '#' + [c.r, c.g, c.b].map(function (v) { return Math.round(v * 255).toString(16).padStart(2, '0'); }).join('');
+                    hardcodedHexSamples.push({ node: node.name, type: node.type, hex: hex });
+                  }
+                }
+              }
+            }
+          }
+          if (Array.isArray(node.strokes) && node.type !== 'INSTANCE') {
+            for (var si = 0; si < node.strokes.length; si++) {
+              var st = node.strokes[si];
+              if (st && st.type === 'SOLID') {
+                metrics.strokesTotal++;
+                var sbv = node.boundVariables && node.boundVariables.strokes;
+                if (sbv && (Array.isArray(sbv) ? sbv[si] : true)) metrics.strokesBound++;
+              }
+            }
+          }
+        } catch (e) { /* skip */ }
+
+        if (node.type === 'FRAME' || node.type === 'COMPONENT' || node.type === 'INSTANCE') {
+          try {
+            var padProps = ['paddingTop', 'paddingBottom', 'paddingLeft', 'paddingRight'];
+            for (var pi = 0; pi < padProps.length; pi++) {
+              var pp = padProps[pi];
+              if (typeof node[pp] === 'number' && node[pp] > 0) {
+                metrics.paddingsTotal++;
+                if (node.boundVariables && node.boundVariables[pp]) metrics.paddingsBound++;
+              }
+            }
+            if (typeof node.itemSpacing === 'number' && node.itemSpacing > 0) {
+              metrics.itemSpacingTotal++;
+              if (node.boundVariables && node.boundVariables.itemSpacing) metrics.itemSpacingBound++;
+            }
+            var radProps = ['cornerRadius', 'topLeftRadius', 'topRightRadius', 'bottomLeftRadius', 'bottomRightRadius'];
+            for (var ri = 0; ri < radProps.length; ri++) {
+              var rp = radProps[ri];
+              if (typeof node[rp] === 'number' && node[rp] > 0) {
+                metrics.radiusTotal++;
+                if (node.boundVariables && node.boundVariables[rp]) metrics.radiusBound++;
+              }
+            }
+            // v1.9.4 detailed: flag primitive frames that *should* have been components
+            if (detailed && node.type === 'FRAME' && node !== rootNode && primitiveFallbacks.length < maxSamples && node.children && node.children.length >= 2) {
+              var onlyPrimitives = true;
+              for (var cpi = 0; cpi < node.children.length; cpi++) {
+                if (node.children[cpi].type === 'INSTANCE') { onlyPrimitives = false; break; }
+              }
+              if (onlyPrimitives) primitiveFallbacks.push({ name: node.name, childCount: node.children.length });
+            }
+          } catch (e) { /* skip */ }
+        }
+
+        if (node.type === 'TEXT') {
+          try {
+            metrics.textsTotal++;
+            if (node.textStyleId && typeof node.textStyleId === 'string' && node.textStyleId !== '') {
+              metrics.textsWithStyle++;
+            } else {
+              metrics.textsHardcodedFontSize++;
+              if (detailed && hardcodedFontSizeSamples.length < maxSamples) {
+                hardcodedFontSizeSamples.push({
+                  text: String(node.characters || '').slice(0, 40),
+                  fontSize: node.fontSize,
+                  fontName: node.fontName,
+                });
+              }
+            }
+            if (Array.isArray(node.fills) && node.fills.length > 0) {
+              metrics.textColorsTotal++;
+              var tbv = node.boundVariables && node.boundVariables.fills;
+              if (tbv && (Array.isArray(tbv) ? tbv[0] : true)) metrics.textColorsBound++;
+            }
+          } catch (e) { /* skip */ }
+        }
+
         // Push children
         if (node.children) {
           for (var ci = 0; ci < node.children.length; ci++) {
@@ -2543,7 +2747,50 @@ figma.ui.onmessage = async (msg) => {
         : 'Score ' + score + '/100 is below minimum ' + minScore + '. Consider deleting this screen and rebuilding using ' +
           'DS components (figma_instantiate_component) and token bindings (figma_bind_variable).';
 
-      figma.ui.postMessage({
+      // v1.9.4: granular bind coverage percentages
+      function pct(b, t) { return t > 0 ? Math.round((b / t) * 100) : 100; }
+      var fillsTotal = metrics.boundFills + metrics.unboundSolidFills;
+      var coverage = {
+        fills: { bound: metrics.boundFills, total: fillsTotal, pct: pct(metrics.boundFills, fillsTotal) },
+        paddings: { bound: metrics.paddingsBound, total: metrics.paddingsTotal, pct: pct(metrics.paddingsBound, metrics.paddingsTotal) },
+        itemSpacing: { bound: metrics.itemSpacingBound, total: metrics.itemSpacingTotal, pct: pct(metrics.itemSpacingBound, metrics.itemSpacingTotal) },
+        radius: { bound: metrics.radiusBound, total: metrics.radiusTotal, pct: pct(metrics.radiusBound, metrics.radiusTotal) },
+        textStyle: { withStyle: metrics.textsWithStyle, hardcoded: metrics.textsHardcodedFontSize, total: metrics.textsTotal, pct: pct(metrics.textsWithStyle, metrics.textsTotal) },
+        textColor: { bound: metrics.textColorsBound, total: metrics.textColorsTotal, pct: pct(metrics.textColorsBound, metrics.textColorsTotal) },
+        strokes: { bound: metrics.strokesBound, total: metrics.strokesTotal, pct: pct(metrics.strokesBound, metrics.strokesTotal) },
+      };
+
+      // v1.9.4: overflow check (root level auto-layout containers)
+      var overflow = null;
+      try {
+        if (rootNode.layoutMode === 'VERTICAL' && rootNode.children) {
+          var contentH = 0;
+          for (var chi = 0; chi < rootNode.children.length; chi++) contentH += (rootNode.children[chi].height || 0);
+          if (rootNode.itemSpacing) contentH += rootNode.itemSpacing * Math.max(0, rootNode.children.length - 1);
+          contentH += (rootNode.paddingTop || 0) + (rootNode.paddingBottom || 0);
+          overflow = {
+            axis: 'VERTICAL',
+            frameSize: Math.round(rootNode.height || 0),
+            contentSize: Math.round(contentH),
+            overflowPx: Math.round(contentH - (rootNode.height || 0)),
+            clipsContent: !!rootNode.clipsContent,
+          };
+        } else if (rootNode.layoutMode === 'HORIZONTAL' && rootNode.children) {
+          var contentW = 0;
+          for (var cwi = 0; cwi < rootNode.children.length; cwi++) contentW += (rootNode.children[cwi].width || 0);
+          if (rootNode.itemSpacing) contentW += rootNode.itemSpacing * Math.max(0, rootNode.children.length - 1);
+          contentW += (rootNode.paddingLeft || 0) + (rootNode.paddingRight || 0);
+          overflow = {
+            axis: 'HORIZONTAL',
+            frameSize: Math.round(rootNode.width || 0),
+            contentSize: Math.round(contentW),
+            overflowPx: Math.round(contentW - (rootNode.width || 0)),
+            clipsContent: !!rootNode.clipsContent,
+          };
+        }
+      } catch (e) { overflow = null; }
+
+      var response = {
         type: 'VALIDATE_SCREEN_RESULT',
         requestId: msg.requestId,
         success: true,
@@ -2561,12 +2808,25 @@ figma.ui.onmessage = async (msg) => {
           nodesWithBindings: metrics.nodesWithBindings,
           totalStylable: metrics.stylableNodes,
         },
+        coverage: coverage, // v1.9.4: granular coverage
+        overflow: overflow, // v1.9.4: root auto-layout overflow
         violations: violations,
         violationCount: violations.length,
         violationCapped: violations.length >= maxViolations,
         totalNodesWalked: visited,
         recommendation: recommendation,
-      });
+      };
+
+      // v1.9.4: detailed mode — hardcoded samples + primitive fallbacks
+      if (detailed) {
+        response.samples = {
+          hardcodedHex: hardcodedHexSamples,
+          hardcodedFontSize: hardcodedFontSizeSamples,
+          primitiveFrames: primitiveFallbacks,
+        };
+      }
+
+      figma.ui.postMessage(response);
     } catch (error) {
       var errorMsg = error && error.message ? error.message : String(error);
       console.error('🌉 [F-MCP] Validate screen error:', errorMsg);
@@ -2815,64 +3075,140 @@ figma.ui.onmessage = async (msg) => {
   // ============================================================================
   else if (msg.type === 'CAPTURE_SCREENSHOT') {
     try {
-      console.log('🌉 [F-MCP ATezer Bridge] Capturing screenshot for node:', msg.nodeId);
+      console.log('🌉 [F-MCP ATezer Bridge v1.9.5] Capturing screenshot for node:', msg.nodeId, 'returnMode:', msg.returnMode);
 
       var node = msg.nodeId ? await figma.getNodeByIdAsync(msg.nodeId) : figma.currentPage;
       if (!node) {
         throw new Error('Node not found: ' + msg.nodeId);
       }
 
-      // Verify node supports export
-      if (!('exportAsync' in node)) {
-        throw new Error('Node type ' + node.type + ' does not support export');
-      }
-
-      // v1.8.0: Default JPG@1x q70 for context safety. Plugin reads msg.format,
-      // msg.scale, msg.jpegQuality from the request payload (passed through
-      // captureScreenshot connector → bridge → here).
+      // v1.8.0: Default JPG@1x q70 for context safety.
       var format = (msg.format || 'JPG').toUpperCase();
       var scale = msg.scale != null ? msg.scale : 1;
       var jpegQuality = msg.jpegQuality != null ? msg.jpegQuality : 70;
+      // v1.9.5: returnMode (default 'file' which server translates to base64 + save)
+      var returnMode = msg.returnMode || 'base64';  // plugin default stays base64; server wraps to file
+      var regionStrategy = msg.regionStrategy || 'children';
+      var maxRegions = msg.maxRegions != null ? msg.maxRegions : 8;
 
-      var exportSettings = {
-        format: format,
-        constraint: { type: 'SCALE', value: scale }
-      };
-      // JPG quality (Figma Plugin API supports 'quality' for ExportSettingsImage)
-      if (format === 'JPG') {
-        exportSettings.quality = jpegQuality;
+      function buildExportSettings() {
+        var s = { format: format, constraint: { type: 'SCALE', value: scale } };
+        if (format === 'JPG') s.quality = jpegQuality;
+        return s;
       }
 
-      // Export the node
-      var bytes = await node.exportAsync(exportSettings);
+      // ---------- v1.9.5 MODE: summary ----------
+      // No export. Just metadata.
+      if (returnMode === 'summary') {
+        var rootSummary = await buildNodeSummary(node, /*depth*/ 2);
+        figma.ui.postMessage({
+          type: 'CAPTURE_SCREENSHOT_RESULT',
+          requestId: msg.requestId,
+          success: true,
+          mode: 'summary',
+          summary: rootSummary,
+        });
+        return;
+      }
 
-      // Convert to base64
-      var base64 = figma.base64Encode(bytes);
+      // ---------- v1.9.5 MODE: regions (children strategy) ----------
+      if (returnMode === 'regions' && regionStrategy === 'children') {
+        if (!node.children || node.children.length === 0) {
+          figma.ui.postMessage({
+            type: 'CAPTURE_SCREENSHOT_RESULT',
+            requestId: msg.requestId,
+            success: false,
+            error: "Node has no children for regions mode. Use 'file' or 'summary' instead.",
+          });
+          return;
+        }
+        var regions = [];
+        var children = node.children.slice(0, maxRegions);
+        for (var ri = 0; ri < children.length; ri++) {
+          var child = children[ri];
+          if (!('exportAsync' in child)) continue;
+          try {
+            var cbytes = await child.exportAsync(buildExportSettings());
+            var cbase64 = figma.base64Encode(cbytes);
+            regions.push({
+              name: child.name,
+              nodeId: child.id,
+              type: child.type,
+              image: {
+                base64: cbase64,
+                format: format,
+                scale: scale,
+                byteLength: cbytes.length,
+                width: child.width,
+                height: child.height,
+              },
+            });
+          } catch (childErr) {
+            regions.push({
+              name: child.name,
+              nodeId: child.id,
+              error: childErr && childErr.message ? childErr.message : String(childErr),
+            });
+          }
+        }
+        figma.ui.postMessage({
+          type: 'CAPTURE_SCREENSHOT_RESULT',
+          requestId: msg.requestId,
+          success: true,
+          mode: 'regions',
+          regionStrategy: 'children',
+          regions: regions,
+          totalRegions: regions.length,
+          rootSummary: {
+            nodeId: node.id,
+            name: node.name,
+            dimensions: { width: node.width, height: node.height },
+            childrenCount: node.children.length,
+            capped: node.children.length > maxRegions,
+          },
+        });
+        return;
+      }
 
-      // Get node bounds for context
-      var bounds = null;
-      if ('absoluteBoundingBox' in node) {
-        bounds = node.absoluteBoundingBox;
+      // ---------- v1.9.5 MODE: regions (slices strategy) — NOT SUPPORTED YET ----------
+      if (returnMode === 'regions' && regionStrategy === 'slices') {
+        // Figma exportAsync does not support crop regions natively.
+        // Fallback: return a warning + single full image export.
+        figma.ui.postMessage({
+          type: 'CAPTURE_SCREENSHOT_RESULT',
+          requestId: msg.requestId,
+          success: false,
+          error: "regionStrategy='slices' not supported in v1.9.5. Use regionStrategy='children' or returnMode='summary'.",
+        });
+        return;
+      }
+
+      // ---------- DEFAULT: full single export (base64 or file — server post-processes) ----------
+      if (!('exportAsync' in node)) {
+        throw new Error('Node type ' + node.type + ' does not support export');
       }
 
-      console.log('🌉 [F-MCP ATezer Bridge] Screenshot captured:', bytes.length, 'bytes (' + format + ' @' + scale + 'x)');
+      var bytes = await node.exportAsync(buildExportSettings());
+      var base64 = figma.base64Encode(bytes);
+      var bounds = ('absoluteBoundingBox' in node) ? node.absoluteBoundingBox : null;
+
+      console.log('🌉 [F-MCP ATezer Bridge v1.9.5] Screenshot captured:', bytes.length, 'bytes (' + format + ' @' + scale + 'x)');
 
       figma.ui.postMessage({
         type: 'CAPTURE_SCREENSHOT_RESULT',
         requestId: msg.requestId,
         success: true,
+        mode: returnMode,  // 'file' or 'base64' (server post-processes 'file' mode)
         image: {
           base64: base64,
           format: format,
           scale: scale,
           jpegQuality: format === 'JPG' ? jpegQuality : null,
           byteLength: bytes.length,
-          node: {
-            id: node.id,
-            name: node.name,
-            type: node.type
-          },
-          bounds: bounds
+          width: node.width,
+          height: node.height,
+          node: { id: node.id, name: node.name, type: node.type },
+          bounds: bounds,
         }
       });
 

package/f-mcp-plugin/ui.html

@@ -424,7 +424,7 @@
     window.__figmaFileName = null;
     // v1.8.0+: Plugin version reported in WebSocket "ready" handshake.
     // Keep in sync with package.json, src/core/version.ts, f-mcp-plugin/code.js.
-    var FMCP_PLUGIN_VERSION = '1.9.2';
+    var FMCP_PLUGIN_VERSION = '1.9.5';
 
     // v1.9.2+ Startup log — Figma plugin iframe'de yeni kod yüklendiğini doğrulamak için.
     // Console'da bu log görünüyorsa plugin güncel. Görünmüyorsa iframe eski kopyayı tutuyor

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atezer/figma-mcp-bridge",
-	"version": "1.9.3",
+	"version": "1.9.5",
 	"description": "F-MCP ATezer: MCP server and Figma plugin bridge for Claude/Cursor. No REST token required.",
 	"type": "module",
 	"main": "dist/local-plugin-only.js",

package/skills/figma-canvas-ops/SKILL.md

@@ -119,6 +119,54 @@ active-ds.md `❌` ise: "Hangi DS? (SUI / Material / HIG / Kendi / Hiçbiri)". Y
 
     Hardcoded `node.fills = [{ type: "SOLID", color: {...} }]` YASAK.
 
+10a. **Inline Bind Verification (v1.9.4, ZORUNLU).** Her execute sonunda oluşturulan node'ları tara. Bind eksikse `throw` atılır — execute başarısız sayılır, Claude retry eder. Şablon:
+
+    ```js
+    // Execute'un sonunda, createdNodes listesini tarayıp bind kontrolü yap:
+    function assertBound(node) {
+      // Fill bind
+      if (Array.isArray(node.fills)) {
+        for (var i = 0; i < node.fills.length; i++) {
+          var f = node.fills[i];
+          if (f && f.visible !== false && f.type === "SOLID") {
+            var fbv = node.boundVariables && node.boundVariables.fills;
+            var bound = fbv && (Array.isArray(fbv) ? fbv[i] : true);
+            if (!bound) throw new Error("UNBOUND_FILL: " + node.name + " — setBoundVariableForPaint cagrisi eksik");
+          }
+        }
+      }
+      // Padding/itemSpacing/radius bind (auto-layout frame)
+      if (node.type === "FRAME" || node.type === "COMPONENT") {
+        var padProps = ["paddingTop","paddingBottom","paddingLeft","paddingRight"];
+        for (var j = 0; j < padProps.length; j++) {
+          var p = padProps[j];
+          if (typeof node[p] === "number" && node[p] > 0 && !(node.boundVariables && node.boundVariables[p])) {
+            throw new Error("UNBOUND_PADDING: " + node.name + "." + p + "=" + node[p] + " — setBoundVariable cagrisi eksik");
+          }
+        }
+        if (typeof node.itemSpacing === "number" && node.itemSpacing > 0 && !(node.boundVariables && node.boundVariables.itemSpacing)) {
+          throw new Error("UNBOUND_ITEMSPACING: " + node.name + " — setBoundVariable('itemSpacing', v) cagrisi eksik");
+        }
+        var radProps = ["cornerRadius","topLeftRadius","topRightRadius","bottomLeftRadius","bottomRightRadius"];
+        for (var k = 0; k < radProps.length; k++) {
+          var r = radProps[k];
+          if (typeof node[r] === "number" && node[r] > 0 && !(node.boundVariables && node.boundVariables[r])) {
+            throw new Error("UNBOUND_RADIUS: " + node.name + "." + r + "=" + node[r]);
+          }
+        }
+      }
+      // Text style
+      if (node.type === "TEXT" && !(node.textStyleId && typeof node.textStyleId === "string" && node.textStyleId !== "")) {
+        throw new Error("UNBOUND_TEXTSTYLE: '" + (node.characters||"").slice(0,30) + "' — setTextStyleIdAsync(style.id) cagrisi eksik");
+      }
+    }
+
+    // Tüm oluşturulan node'ları doğrula:
+    for (var n = 0; n < createdNodes.length; n++) assertBound(createdNodes[n]);
+    ```
+
+    Bu kontrol atlanırsa `figma_scan_ds_compliance` final gate'te sonuç zaten BLOCKING olur — ama inline check erkendedir ve context'i az yer. **v1.9.4 önerisi:** Her mega-step sonunda bu assertion bloğunu execute'un sonuna koy.
+
 11. **appendChild sıralaması kritik.** ÖNCE `parent.appendChild(child)`, SONRA `child.layoutSizingHorizontal = "FILL"` / `layoutPositioning = "ABSOLUTE"`:
     ```js
     parent.appendChild(child);              // ÖNCE
@@ -136,6 +184,26 @@ active-ds.md `❌` ise: "Hangi DS? (SUI / Material / HIG / Kendi / Hiçbiri)". Y
 
 16. **Her Promise'i `await` et.**
 
+17. **v1.9.5 Concise Query Rule — tek satır boyut/metadata sorguları.**
+
+    Boyut, renk, layout sorgulamak için **20+ satır JS YAZMA**. Tek satır yeter:
+
+    ```js
+    // İYİ — tek satır, minimal context
+    return await figma.getNodeByIdAsync(id).then(n => ({ w: n.width, h: n.height, children: n.children?.length }));
+
+    // İYİ — toplu (birden fazla node)
+    return Promise.all(ids.map(async id => {
+      const n = await figma.getNodeByIdAsync(id);
+      return { id, name: n?.name, size: n ? [n.width, n.height] : null };
+    }));
+
+    // KÖTÜ — 30 satır "defensive" kod boyut sorgusu için
+    // await figma.loadAllPagesAsync(); for (var pg of ...) { if (...) ... }
+    ```
+
+    **Kural:** Tek nodeId için size → 1 satır. Multi-node metadata → 1 Promise.all. Complex traversal sadece üretim mantığında gerekli — keşifte değil.
+
 ## 2. Sayfa Kuralları
 
 ```js

package/skills/fmcp-intent-router/SKILL.md

@@ -226,6 +226,15 @@ FOR each input in required_inputs:
 
 Missing list'teki tüm soruları **TEK** `AskUserQuestion` çağrısında toplayıp sor. Max 4 soru/çağrı (AskUserQuestion limiti). 5+ soru gerekiyorsa 2 ayrı çağrı yap, ama ÖNCE kritik 4'ü sor, sonra kalanları.
 
+### v1.9.5 Elicitation Kuralı (SERT)
+
+- **Maks 1 `AskUserQuestion` çağrısı** tüm oturum boyunca. Tekrar soru sormak yasak — state'ten veya context'ten çıkar.
+- **"devam et" / "tamam" / "ok" / "yap" sonrası soru YASAK.** Kullanıcı onay verdi → üretime geç.
+- User prompt'u anlamlıysa (spesifik ekran adı, boyut, DS veriliyorsa) **hiç sorma**, direkt planla ve göster.
+- **"Sen seç"** cevabı alırsan: mantıklı default kullan (iPhone 17, mobile, single variant, active DS).
+- Sorulan her soru ≤30 kelime — uzun elicitation yasak.
+- Soruyu sormanın context maliyeti ≥ yanıtın değeri mi? Değilse sorma.
+
 **Örnek — generate-figma-screen:**
 
 ```

package/skills/fmcp-screen-orchestrator/SKILL.md

@@ -144,6 +144,35 @@ Benchmark/görselden DEĞER alma YASAK. Sadece NİYET: layout yönü, hiyerarşi
 2. **Content** — DS instance yerleşimi → screenshot → onay
 3. **Polish** — spacing, states, edge cases → son screenshot → audit
 
+### v1.9.5 Discovery Budget Rule (SERT)
+
+- **Maks 3 discovery çağrısı** (figma_get_*, figma_search_*, figma_execute read-only) sonra plan sun.
+- Plan kullanıcıya 1-2 cümle + varsa özet: "Şu ekran/section'ları oluşturacağım: [liste]. Onay veriyor musun?"
+- Kullanıcı onay verdikten sonra **mutation** aşamasına geç (figma_execute createFrame/setFills/setBoundVariable) — discovery counter reset olur.
+- Plugin 8 çağrıdan sonra `_warnings: ["DISCOVERY_BUDGET_WARNING..."]` döner — görünce üretime geçmek zorundasın.
+- 12 çağrıdan sonra `_DISCOVERY_BUDGET_EXCEEDED_BLOCKING: true` döner — **skip edilemez**, plan sun veya dur.
+
+### v1.9.5 Screenshot Method Selection (KARAR AĞACI)
+
+Ekran yakalama isteği olduğunda şu ağacı takip et:
+
+```
+İhtiyaç ne?
+├── "Planlama yapacağım, layout anlamak istiyorum" → returnMode: "summary" (metadata, screenshotsuz)
+├── "Kullanıcıya son halini göstereyim" → returnMode: "file" (1 screenshot dosyaya)
+├── "Büyük/scroll'lu ekran, bölümleri görmek istiyorum" → returnMode: "regions", regionStrategy: "children"
+├── "Üretim sonrası hızlı validation" → returnMode: "file"
+├── "Spesifik region (örn Hero)" → single-node file veya regions children maxRegions=3
+└── "Base64 context'te gerekli (nadiren)" → returnMode: "base64" (explicit, _warning ile)
+```
+
+**Budget farkındalığı:**
+- Bir oturumda >3 farklı nodeId için screenshot → 4. için zorunlu `summary` veya `regions`
+- Response'da `_warnings: ["CONTEXT_NEAR_LIMIT"]` veya `"DISCOVERY_BUDGET_..."` görürsen → sonraki screenshot zorunlu `summary`
+- Pixel-perfect değil, **region-perfect** düşün: "Hero'yu göreyim, gerekirse Actions'ı da" — hepsi birden değil
+
+**Kritik:** Screenshot YASAK değil. "Yasak" yerine **doğru yöntem** kullan. Her mode'un kullanım amacı var.
+
 ### Error Recovery
 
 | Hata | Aksiyon |