@nick848/fet 1.1.6 → 1.1.7

package/dist/cli/index.js

@@ -188,18 +188,18 @@ function toGitNexusState(detection, previous) {
   };
 }
 async function inspectGitNexusGraph(projectRoot, env = process.env) {
-  const relative3 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
-  const graphPath = join5(projectRoot, relative3);
+  const relative4 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
+  const graphPath = join5(projectRoot, relative4);
   try {
     const info = await stat2(graphPath);
     return {
-      graphPath: relative3,
+      graphPath: relative4,
       graphExists: true,
       lastIndexedAt: info.mtime.toISOString()
     };
   } catch {
     return {
-      graphPath: relative3,
+      graphPath: relative4,
       graphExists: false,
       lastIndexedAt: null
     };
@@ -2079,6 +2079,10 @@ function renderFetConfig(scan, language = "zh-CN") {
           test: "warn"
         },
         workspaces: scan.project.workspaces
+      },
+      figmaGuard: {
+        enabled: true,
+        onUncertainty: "stop_and_ask"
       }
     }
   });
@@ -2239,6 +2243,118 @@ fet verify --done --change ${changeId}
 `;
 }
 
+// src/templates/figma-guard.ts
+var FIGMA_URL_PATTERN = /https?:\/\/(?:www\.)?figma\.com\/(?:file|design|proto)\/[^\s)\]"'<>]+/gi;
+function figmaStopHandoffRelativePath(changeId) {
+  return `openspec/changes/${changeId}/.fet/figma-stop.md`;
+}
+function renderFigmaStopProtocolBody(language) {
+  if (language === "en") {
+    return `## Stop immediately (do not write or change UI code) when
+
+- Figma MCP/API errors, 403, timeout, or empty node/selection
+- You cannot resolve the frame or node referenced in the change
+- Color, typography, spacing, radius, shadow, or layout cannot be determined from the design input
+- Component instances do not map to an agreed code component and the user has not chosen one
+- Interaction states (hover, disabled, loading, empty) are missing from the design
+
+## After stopping, ask the user
+
+1. What failed (permission, node, frame, token type)
+2. What you need: **viewable link**, **screenshot + short notes**, or **explicit permission to infer** (which rule)
+3. Do **not** continue UI implementation until the user clearly says to continue or answers the question
+
+## While uncertain
+
+- Do not fill gaps with "common UI patterns" or guessed pixel values
+- Prefer showing the blocking question over partial implementation`;
+  }
+  return `## \u5FC5\u987B\u7ACB\u5373\u505C\u6B62\uFF08\u4E0D\u5F97\u7EE7\u7EED\u7F16\u5199\u6216\u4FEE\u6539 UI \u4EE3\u7801\uFF09\u5F53
+
+- Figma MCP/API \u62A5\u9519\u3001403\u3001\u8D85\u65F6\uFF0C\u6216\u8282\u70B9/\u9009\u533A\u4E3A\u7A7A
+- \u65E0\u6CD5\u89E3\u6790 change \u4E2D\u5F15\u7528\u7684\u753B\u677F\u6216\u8282\u70B9
+- \u989C\u8272\u3001\u5B57\u53F7\u3001\u95F4\u8DDD\u3001\u5706\u89D2\u3001\u9634\u5F71\u3001\u5E03\u5C40\u65E0\u6CD5\u4ECE\u8BBE\u8BA1\u8F93\u5165\u4E2D\u786E\u5B9A
+- \u7EC4\u4EF6\u5B9E\u4F8B\u65E0\u6CD5\u5BF9\u5E94\u5230\u5DF2\u7EA6\u5B9A\u7684\u4EE3\u7801\u7EC4\u4EF6\uFF0C\u4E14\u7528\u6237\u672A\u6307\u5B9A
+- \u4EA4\u4E92\u72B6\u6001\uFF08hover\u3001disabled\u3001loading\u3001\u7A7A\u6001\u7B49\uFF09\u5728\u8BBE\u8BA1\u7A3F\u4E2D\u7F3A\u5931
+
+## \u505C\u6B62\u540E\u5FC5\u987B\u8BE2\u95EE\u7528\u6237
+
+1. \u5361\u5728\u54EA\u4E00\u6B65\uFF08\u6743\u9650\u3001\u8282\u70B9\u3001\u753B\u677F\u3001\u54EA\u7C7B token\uFF09
+2. \u9700\u8981\u7528\u6237\u8865\u5145\uFF1A**\u53EF\u67E5\u770B\u7684\u94FE\u63A5**\u3001**\u622A\u56FE + \u6587\u5B57\u8BF4\u660E**\uFF0C\u6216 **\u660E\u786E\u5141\u8BB8\u6309\u67D0\u89C4\u5219\u63A8\u65AD**
+3. \u5728\u7528\u6237\u660E\u786E\u8868\u793A\u300C\u7EE7\u7EED\u300D\u6216\u56DE\u7B54\u95EE\u9898\u4E4B\u524D\uFF0C**\u4E0D\u8981**\u7EE7\u7EED\u5B9E\u73B0 UI
+
+## \u5B58\u5728\u4E0D\u786E\u5B9A\u6027\u65F6
+
+- \u4E0D\u8981\u7528\u300C\u5E38\u89C1 UI \u505A\u6CD5\u300D\u6216\u731C\u6D4B\u7684\u50CF\u7D20\u503C\u586B\u8865\u7A7A\u767D
+- \u4F18\u5148\u5411\u7528\u6237\u63D0\u95EE\uFF0C\u800C\u4E0D\u662F\u5148\u5199\u4E00\u7248\u6837\u5F0F\u518D\u6539`;
+}
+function renderCursorFigmaStopRule(language) {
+  const description = language === "en" ? "Stop UI work when Figma cannot be read reliably; ask the user before continuing" : "Figma \u7406\u89E3\u5F02\u5E38\u65F6\u505C\u6B62 UI \u5B9E\u73B0\u5E76\u5411\u7528\u6237\u786E\u8BA4\u540E\u518D\u7EE7\u7EED";
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: cursor-adapter
+adapterVersion: 1
+FET:END -->
+
+---
+description: ${description}
+alwaysApply: false
+---
+
+${language === "en" ? "Apply when the user shares a Figma link, asks to implement from a design file, or uses Figma MCP/tools for UI work." : "\u5728\u7528\u6237\u5206\u4EAB Figma \u94FE\u63A5\u3001\u8981\u6C42\u6309\u8BBE\u8BA1\u7A3F\u5B9E\u73B0 UI\uFF0C\u6216\u4F7F\u7528 Figma MCP/\u5DE5\u5177\u65F6\u9002\u7528\u3002"}
+
+${renderFigmaStopProtocolBody(language)}
+
+${language === "en" ? "If this change has `openspec/changes/<change-id>/.fet/figma-stop.md`, read it for detected links and repeat the same stop rules." : "\u82E5\u5F53\u524D change \u5B58\u5728 `openspec/changes/<change-id>/.fet/figma-stop.md`\uFF0C\u8BF7\u5148\u9605\u8BFB\u5176\u4E2D\u7684\u94FE\u63A5\u5217\u8868\uFF0C\u5E76\u9075\u5B88\u76F8\u540C\u7684\u505C\u6B62\u89C4\u5219\u3002"}
+`;
+}
+function renderCodexFigmaStopGuide(language) {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: codex-adapter
+adapterVersion: 1
+FET:END -->
+
+# Figma stop protocol (Codex)
+
+${renderFigmaStopProtocolBody(language)}
+`;
+}
+function renderChangeFigmaStopHandoff(options) {
+  const linkList = options.urls.length ? options.urls.map((url) => `- ${url}`).join("\n") : options.language === "en" ? "- (none detected in change artifacts; user may still reference Figma in chat)" : "- \uFF08change \u4EA7\u7269\u4E2D\u672A\u68C0\u6D4B\u5230\uFF1B\u7528\u6237\u4ECD\u53EF\u80FD\u5728\u5BF9\u8BDD\u4E2D\u63D0\u4F9B Figma\uFF09";
+  const sourceList = options.sources.length ? options.sources.map((source) => `- ${source}`).join("\n") : options.language === "en" ? "- n/a" : "- \u65E0";
+  const title = options.language === "en" ? "Figma guard (this change)" : "Figma \u5B88\u536B\uFF08\u672C change\uFF09";
+  const intro = options.language === "en" ? "FET detected Figma links in this change. When design input is unclear, **stop** and let the user decide whether to continue or clarify." : "FET \u5728\u672C change \u4E2D\u68C0\u6D4B\u5230 Figma \u94FE\u63A5\u3002\u8BBE\u8BA1\u8F93\u5165\u4E0D\u6E05\u6670\u65F6\uFF0C**\u505C\u6B62**\u5F53\u524D\u64CD\u4F5C\uFF0C\u7531\u7528\u6237\u51B3\u5B9A\u662F\u7EE7\u7EED\u8FD8\u662F\u8865\u5145\u8BF4\u660E\u3002";
+  return `---
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generatedAt: ${options.generatedAt}
+changeId: ${options.changeId}
+purpose: figma-stop
+---
+
+# ${title}
+
+${intro}
+
+## Detected Figma links
+
+${linkList}
+
+## Sources
+
+${sourceList}
+
+${renderFigmaStopProtocolBody(options.language)}
+`;
+}
+function renderFigmaStopNextStep(changeId, language) {
+  const path = figmaStopHandoffRelativePath(changeId);
+  return language === "en" ? `Before UI implementation, read ${path}. If Figma access fails or design details are unclear, stop and ask the user\u2014do not guess styles.` : `\u5B9E\u65BD UI \u524D\u9605\u8BFB ${path}\u3002Figma \u8BBF\u95EE\u5931\u8D25\u6216\u8BBE\u8BA1\u7EC6\u8282\u4E0D\u660E\u786E\u65F6\u7ACB\u5373\u505C\u6B62\u5E76\u5411\u7528\u6237\u63D0\u95EE\uFF0C\u4E0D\u8981\u731C\u6D4B\u6837\u5F0F\u3002`;
+}
+
 // src/commands/update-context.ts
 async function updateContextCommand(ctx) {
   let contextResult = { warnings: [] };
@@ -2400,8 +2516,128 @@ async function exists4(path) {
 }
 
 // src/commands/proxy.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join18 } from "path";
+
+// src/figma-guard.ts
+import { readdir as readdir3, readFile as readFile11, stat as stat7 } from "fs/promises";
+import { join as join16, relative as relative2 } from "path";
+import { parseDocument as parseDocument2 } from "yaml";
+var DEFAULT_CONFIG = {
+  enabled: true,
+  onUncertainty: "stop_and_ask"
+};
+async function loadFigmaGuardConfig(projectRoot) {
+  try {
+    const raw = await readFile11(join16(projectRoot, "openspec", "config.yaml"), "utf8");
+    const doc = parseDocument2(raw);
+    const fetNode = doc.get("fet", true);
+    const node = fetNode?.get?.("figmaGuard");
+    if (!node || typeof node.get !== "function") {
+      return DEFAULT_CONFIG;
+    }
+    const enabled = node.get("enabled");
+    return {
+      enabled: enabled === void 0 ? true : Boolean(enabled),
+      onUncertainty: "stop_and_ask"
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function extractFigmaUrls(content) {
+  const matches = content.match(FIGMA_URL_PATTERN) ?? [];
+  return [...new Set(matches.map((url) => url.replace(/[.,;]+$/, "")))];
+}
+async function collectFigmaUrlsFromChange(projectRoot, changeId) {
+  const changePath = join16(projectRoot, "openspec", "changes", changeId);
+  const urls = /* @__PURE__ */ new Set();
+  const sources = [];
+  const candidates = ["proposal.md", "tasks.md", "design.md"];
+  for (const name of candidates) {
+    const filePath = join16(changePath, name);
+    const content = await readOptional3(filePath);
+    if (!content) {
+      continue;
+    }
+    const found = extractFigmaUrls(content);
+    if (found.length) {
+      sources.push(`openspec/changes/${changeId}/${name}`);
+      for (const url of found) {
+        urls.add(url);
+      }
+    }
+  }
+  const specsPath = join16(changePath, "specs");
+  for (const filePath of await listMarkdownFiles(specsPath)) {
+    const content = await readOptional3(filePath);
+    if (!content) {
+      continue;
+    }
+    const found = extractFigmaUrls(content);
+    if (found.length) {
+      sources.push(relative2(projectRoot, filePath).replaceAll("\\", "/"));
+      for (const url of found) {
+        urls.add(url);
+      }
+    }
+  }
+  return { urls: [...urls], sources };
+}
+async function ensureChangeFigmaStopHandoff(options) {
+  const config = options.enabled === void 0 ? await loadFigmaGuardConfig(options.projectRoot) : { enabled: options.enabled, onUncertainty: "stop_and_ask" };
+  if (!config.enabled) {
+    return null;
+  }
+  const { urls, sources } = await collectFigmaUrlsFromChange(options.projectRoot, options.changeId);
+  if (!urls.length) {
+    return null;
+  }
+  const relativePath = figmaStopHandoffRelativePath(options.changeId);
+  const absolutePath = join16(options.projectRoot, relativePath);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const content = renderChangeFigmaStopHandoff({
+    changeId: options.changeId,
+    generatedAt,
+    urls,
+    sources,
+    language: options.language
+  });
+  const existing = await readOptional3(absolutePath);
+  const written = existing !== content;
+  if (written) {
+    await atomicWrite(absolutePath, content);
+  }
+  return { path: relativePath, written, urls, sources };
+}
+async function listMarkdownFiles(root) {
+  const files = [];
+  await walk(root, files);
+  return files;
+}
+async function walk(dir, files) {
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join16(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath, files);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+    return;
+  }
+}
+async function readOptional3(path) {
+  try {
+    await stat7(path);
+    return await readFile11(path, "utf8");
+  } catch {
+    return null;
+  }
+}
 
 // src/state/project.ts
 import { execFile as execFile2 } from "child_process";
@@ -2430,8 +2666,8 @@ async function git(cwd, args) {
 }
 
 // src/state/store.ts
-import { mkdir as mkdir6, readFile as readFile11 } from "fs/promises";
-import { join as join16 } from "path";
+import { mkdir as mkdir6, readFile as readFile12 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/language.ts
 var DEFAULT_LANGUAGE = "zh-CN";
@@ -2549,7 +2785,7 @@ var StateStore = class {
   project;
   async readGlobal() {
     try {
-      const value = JSON.parse(await readFile11(this.globalPath(), "utf8"));
+      const value = JSON.parse(await readFile12(this.globalPath(), "utf8"));
       assertGlobalState(value);
       return value;
     } catch (error) {
@@ -2564,13 +2800,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join16(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir6(join17(this.projectRoot, "openspec"), { recursive: true });
     await atomicWrite(this.globalPath(), `${JSON.stringify(state, null, 2)}
 `);
   }
   async readChange(changeId) {
     try {
-      const value = JSON.parse(await readFile11(this.changePath(changeId), "utf8"));
+      const value = JSON.parse(await readFile12(this.changePath(changeId), "utf8"));
       assertChangeState(value);
       return value;
     } catch (error) {
@@ -2585,15 +2821,15 @@ var StateStore = class {
   }
   async writeChange(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join16(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
+    await mkdir6(join17(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
     await atomicWrite(this.changePath(state.changeId), `${JSON.stringify(state, null, 2)}
 `);
   }
   globalPath() {
-    return join16(this.projectRoot, "openspec", "fet-state.json");
+    return join17(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join16(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join17(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -2601,11 +2837,11 @@ function isNotFound(error) {
 }
 
 // src/state/tasks.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 async function readCompletedTaskIds(tasksPath) {
   let content;
   try {
-    content = await readFile12(tasksPath, "utf8");
+    content = await readFile13(tasksPath, "utf8");
   } catch {
     return [];
   }
@@ -2754,21 +2990,31 @@ async function applyWorkflowCommand(ctx, args) {
       exitCode: instructions.exitCode,
       phaseStatus: "in_progress"
     });
+    const figmaGuard = await ensureChangeFigmaStopHandoff({
+      projectRoot: ctx.projectRoot,
+      changeId,
+      language: ctx.language
+    });
+    const applyNextSteps = [
+      `Read openspec/changes/${changeId}/tasks.md and the instructions output.`,
+      "Implement pending tasks and update task checkboxes only after the work is done.",
+      `Run fet verify --change ${changeId}`
+    ];
+    if (figmaGuard) {
+      applyNextSteps.unshift(renderFigmaStopNextStep(changeId, ctx.language));
+    }
     ctx.output.result({
       ok: true,
       command: "apply",
       summary: `fet apply prepared implementation instructions for change "${changeId}".`,
       warnings: [...runState.graphContext?.warnings ?? [], ...warnings ?? []],
-      nextSteps: [
-        `Read openspec/changes/${changeId}/tasks.md and the instructions output.`,
-        "Implement pending tasks and update task checkboxes only after the work is done.",
-        `Run fet verify --change ${changeId}`
-      ],
+      nextSteps: applyNextSteps,
       data: {
         changeId,
         instructions: instructions.data,
         status,
-        graphContext: runState.graphContext
+        graphContext: runState.graphContext,
+        figmaGuard: figmaGuard ?? void 0
       }
     });
   });
@@ -2781,16 +3027,25 @@ async function exploreWorkflowCommand(ctx, args) {
     args: openSpecArgs,
     changeId
   });
+  const figmaGuard = changeId ? await ensureChangeFigmaStopHandoff({
+    projectRoot: ctx.projectRoot,
+    changeId,
+    language: ctx.language
+  }) : null;
+  const exploreNextSteps = [
+    "Discuss the requirement, constraints, and acceptance criteria with the user.",
+    changeId ? `Run fet continue --change ${changeId} when ready to create the next artifact.` : "Run fet propose <change-id-or-description> when ready to create a change."
+  ];
+  if (figmaGuard) {
+    exploreNextSteps.unshift(renderFigmaStopNextStep(changeId, ctx.language));
+  }
   ctx.output.result({
     ok: true,
     command: "explore",
     summary: "fet explore is an IDE-guided workflow for shaping OpenSpec changes.",
     warnings: graphContext.warnings,
-    nextSteps: [
-      "Discuss the requirement, constraints, and acceptance criteria with the user.",
-      changeId ? `Run fet continue --change ${changeId} when ready to create the next artifact.` : "Run fet propose <change-id-or-description> when ready to create a change."
-    ],
-    data: { changeId, args: openSpecArgs, graphContext }
+    nextSteps: exploreNextSteps,
+    data: { changeId, args: openSpecArgs, graphContext, figmaGuard: figmaGuard ?? void 0 }
   });
 }
 async function syncWorkflowCommand(ctx, args) {
@@ -2911,23 +3166,33 @@ async function artifactWorkflowCommand(ctx, command, args) {
       exitCode: instructions.exitCode
     });
     const status = await readOpenSpecStatus(ctx, changeId);
+    const figmaGuard = await ensureChangeFigmaStopHandoff({
+      projectRoot: ctx.projectRoot,
+      changeId,
+      language: ctx.language
+    });
+    const planningNextSteps = [
+      `Create or update openspec/changes/${changeId}/${resolveOutputPath(status, artifactId)}`,
+      "Review the artifact with the user before generating the next planning file.",
+      `Run fet passthrough status --change ${changeId}`,
+      status.isComplete ? `Run fet apply --change ${changeId}` : `Run fet continue --change ${changeId} when ready for the next artifact`
+    ];
+    if (figmaGuard) {
+      planningNextSteps.unshift(renderFigmaStopNextStep(changeId, ctx.language));
+    }
     ctx.output.result({
       ok: true,
       command,
       summary: `fet ${command} prepared OpenSpec artifact "${artifactId}" for change "${changeId}".`,
       warnings: runState.graphContext?.warnings,
-      nextSteps: [
-        `Create or update openspec/changes/${changeId}/${resolveOutputPath(status, artifactId)}`,
-        "Review the artifact with the user before generating the next planning file.",
-        `Run fet passthrough status --change ${changeId}`,
-        status.isComplete ? `Run fet apply --change ${changeId}` : `Run fet continue --change ${changeId} when ready for the next artifact`
-      ],
+      nextSteps: planningNextSteps,
       data: {
         changeId,
         artifactId,
         instructions: instructions.data,
         status,
-        graphContext: runState.graphContext
+        graphContext: runState.graphContext,
+        figmaGuard: figmaGuard ?? void 0
       }
     });
   });
@@ -3133,8 +3398,8 @@ async function createChangelogEntry(projectRoot, changeId) {
   };
 }
 async function appendChangelog(projectRoot, entry) {
-  const changelogPath = join17(projectRoot, "CHANGELOG.md");
-  const existing = await readOptional3(changelogPath);
+  const changelogPath = join18(projectRoot, "CHANGELOG.md");
+  const existing = await readOptional4(changelogPath);
   const legacyContentLabel = "\u66F4\u65B0\u5185\u5BB9";
   const block = `updateTime: ${entry.updateTime}
 changeRequirement:${entry.content}
@@ -3146,12 +3411,12 @@ ${block}` : block;
   await atomicWrite(changelogPath, next);
 }
 async function readChangeRequirement(projectRoot, changeId) {
-  const changeRoot = join17(projectRoot, "openspec", "changes", changeId);
-  const proposal = await readOptional3(join17(changeRoot, "proposal.md"));
+  const changeRoot = join18(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional4(join18(changeRoot, "proposal.md"));
   if (proposal) {
     return summarizeMarkdown(proposal);
   }
-  const readme = await readOptional3(join17(changeRoot, "README.md"));
+  const readme = await readOptional4(join18(changeRoot, "README.md"));
   if (readme) {
     return summarizeMarkdown(readme);
   }
@@ -3161,9 +3426,9 @@ function summarizeMarkdown(content) {
   const normalized = content.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("<!--") && !line.startsWith("---")).join(" ");
   return normalized || "No change requirement found.";
 }
-async function readOptional3(path) {
+async function readOptional4(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch {
     return null;
   }
@@ -3519,8 +3784,8 @@ async function updateCommand(ctx) {
 
 // src/commands/verify.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir7, readFile as readFile14, stat as stat7 } from "fs/promises";
-import { join as join18 } from "path";
+import { mkdir as mkdir7, readFile as readFile15, stat as stat8 } from "fs/promises";
+import { join as join19 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -3587,8 +3852,8 @@ async function verifyCommand(ctx, options) {
 async function writeInstructions(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join18(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
-  const instructionsPath = join18(dir, "verify-instructions.md");
+  const dir = join19(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join19(dir, "verify-instructions.md");
   await mkdir7(dir, { recursive: true });
   await atomicWrite(instructionsPath, renderVerifyInstructions(changeId, generatedAt));
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -3605,7 +3870,7 @@ async function writeInstructions(ctx, changeId) {
 async function markDone(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
   const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
-  const instructionsPath = join18(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
+  const instructionsPath = join19(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
   const instructions = await readInstructions(instructionsPath, changeId);
   const instructionsGeneratedAt = readFrontMatterValue(instructions, "generatedAt") ?? declaredAt;
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -3640,8 +3905,8 @@ async function assertChangeExists(ctx, changeId) {
 }
 async function readInstructions(path, changeId) {
   try {
-    await stat7(path);
-    const content = await readFile14(path, "utf8");
+    await stat8(path);
+    const content = await readFile15(path, "utf8");
     const fileChangeId = readFrontMatterValue(content, "changeId");
     if (fileChangeId !== changeId) {
       throw new FetError({
@@ -3779,9 +4044,9 @@ function renderIdeModelPolicy(command, language = "zh-CN") {
 import { resolve } from "path";
 
 // src/adapters/codex/index.ts
-import { mkdir as mkdir8, readFile as readFile15, stat as stat8 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile16, stat as stat9 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname8, join as join19 } from "path";
+import { dirname as dirname8, join as join20 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -3823,6 +4088,7 @@ Before doing FET or OpenSpec work in Codex, read:
 - AGENTS.md
 - openspec/config.yaml
 - .codex/fet/karpathy-guidelines.md
+- .codex/fet/figma-stop.md when implementing UI from Figma
 - the active change files under openspec/changes/<change-id>/, when a change is selected
 
 If GitNexus code graph context is available in the IDE or MCP tools, prefer it before broad repository scans. Use it to identify relevant modules, dependencies, and insertion points, then read only the concrete source files needed. If GitNexus is unavailable, continue with the normal FET/OpenSpec workflow.
@@ -3841,6 +4107,7 @@ ${languageInstruction(language)}
 - AGENTS.md
 - openspec/config.yaml
 - .codex/fet/karpathy-guidelines.md
+- \u6309 Figma \u5B9E\u73B0 UI \u65F6\u9605\u8BFB .codex/fet/figma-stop.md
 - \u5982\u679C\u5DF2\u9009\u62E9 change\uFF0C\u9605\u8BFB openspec/changes/<change-id>/ \u4E0B\u7684\u5F53\u524D\u4EA7\u7269
 
 \u5982\u679C IDE \u6216 MCP \u5DE5\u5177\u4E2D\u53EF\u7528 GitNexus \u4EE3\u7801\u56FE\u4E0A\u4E0B\u6587\uFF0C\u5148\u7528\u5B83\u7F29\u5C0F\u4ED3\u5E93\u626B\u63CF\u8303\u56F4\uFF1B\u7528\u56FE\u8BC6\u522B\u76F8\u5173\u6A21\u5757\u3001\u4F9D\u8D56\u548C\u63D2\u5165\u70B9\uFF0C\u518D\u53EA\u8BFB\u53D6\u9700\u8981\u786E\u8BA4\u884C\u4E3A\u7684\u5177\u4F53\u6E90\u7801\u6587\u4EF6\u3002GitNexus \u4E0D\u53EF\u7528\u65F6\uFF0C\u6309\u666E\u901A FET/OpenSpec \u5DE5\u4F5C\u6D41\u7EE7\u7EED\u3002
@@ -3861,9 +4128,16 @@ FET:END -->
 ${body}`
   };
 }
+function codexFigmaStopFile(language = DEFAULT_LANGUAGE) {
+  return {
+    path: ".codex/fet/figma-stop.md",
+    content: renderCodexFigmaStopGuide(language)
+  };
+}
 function codexCommandFiles(language = DEFAULT_LANGUAGE) {
   return [
     codexKarpathyGuidelinesFile(language),
+    codexFigmaStopFile(language),
     ...FET_ADAPTER_COMMANDS.map((command) => ({
       path: `.codex/fet/commands/${command}.md`,
       content: renderCommand(command, language)
@@ -4822,7 +5096,7 @@ var CodexAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists5(join19(projectRoot, ".codex")) || await exists5(join19(projectRoot, "AGENTS.md")),
+      detected: await exists5(join20(projectRoot, ".codex")) || await exists5(join20(projectRoot, "AGENTS.md")),
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
@@ -4888,9 +5162,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join19(resolveCodexHome(), file.path);
+    return join20(resolveCodexHome(), file.path);
   }
-  return join19(projectRoot, file.path);
+  return join20(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -4899,18 +5173,18 @@ function displayPathFor(file) {
   return file.path;
 }
 function resolveCodexHome() {
-  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join19(homedir(), ".codex");
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join20(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile15(path, "utf8");
+    return await readFile16(path, "utf8");
   } catch {
     return null;
   }
 }
 async function exists5(path) {
   try {
-    await stat8(path);
+    await stat9(path);
     return true;
   } catch {
     return false;
@@ -4918,10 +5192,19 @@ async function exists5(path) {
 }
 
 // src/adapters/cursor/index.ts
-import { mkdir as mkdir9, readFile as readFile16, stat as stat9 } from "fs/promises";
-import { dirname as dirname9, join as join20 } from "path";
+import { mkdir as mkdir9, readFile as readFile17, stat as stat10 } from "fs/promises";
+import { dirname as dirname9, join as join21 } from "path";
 
 // src/adapters/cursor/templates.ts
+function cursorFigmaStopRuleFile(language = DEFAULT_LANGUAGE) {
+  return {
+    path: ".cursor/rules/fet-figma-stop.mdc",
+    content: renderCursorFigmaStopRule(language)
+  };
+}
+function cursorRuleFiles(language = DEFAULT_LANGUAGE) {
+  return [cursorRuleFile(language), cursorFigmaStopRuleFile(language)];
+}
 function cursorSkillFiles(language = DEFAULT_LANGUAGE) {
   return FET_ADAPTER_COMMANDS.map((command) => ({
     path: `.cursor/skills/fet-${command}/SKILL.md`,
@@ -4951,6 +5234,7 @@ ${languageInstruction(language)}
 - openspec/config.yaml
 - \u53EF\u7528\u65F6\u7684 GitNexus \u4EE3\u7801\u56FE\u4E0A\u4E0B\u6587\u3002\u4F18\u5148\u7528\u5B83\u7F29\u5C0F\u8303\u56F4\uFF1B\u4E0D\u53EF\u7528\u65F6\u6309\u666E\u901A FET/OpenSpec \u5DE5\u4F5C\u6D41\u7EE7\u7EED\u3002
 - \u5F53\u524D change \u76EE\u5F55\u4E0B\u7684 OpenSpec \u89C4\u5212\u4EA7\u7269\u3002
+- \u6309 Figma \u5B9E\u73B0 UI \u65F6\u9075\u5B88 \`.cursor/rules/fet-figma-stop.mdc\`\uFF1B\u82E5\u5B58\u5728 \`openspec/changes/<change-id>/.fet/figma-stop.md\` \u987B\u5148\u9605\u8BFB\u3002
 
 \u5982\u679C\u7528\u6237\u8F93\u5165\u7C7B\u4F3C \`/fet apply\` \u7684\u8BF7\u6C42\uFF0C\u8BF7\u628A\u5B83\u89C6\u4E3A\u5DE5\u4F5C\u6D41\u610F\u56FE\uFF0C\u5E76\u63D0\u793A\u6216\u6267\u884C\u5BF9\u5E94\u7684\u7EC8\u7AEF\u547D\u4EE4 \`fet <cmd>\`\u3002
 `
@@ -5055,14 +5339,14 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists6(join20(projectRoot, ".cursor")),
+      detected: await exists6(join21(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
   async planInstall(_projectRoot, language) {
     return {
       tool: this.tool,
-      files: [...cursorSkillFiles(language), cursorRuleFile(language)].map((file) => ({
+      files: [...cursorSkillFiles(language), ...cursorRuleFiles(language)].map((file) => ({
         ...file,
         managed: true
       }))
@@ -5072,7 +5356,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join20(projectRoot, file.path);
+      const target = join21(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -5095,7 +5379,7 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join20(projectRoot, file.path);
+      const target = join21(projectRoot, file.path);
       const content = await readExisting2(target);
       const managed = Boolean(content?.includes("FET:MANAGED"));
       const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
@@ -5111,14 +5395,14 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile16(path, "utf8");
+    return await readFile17(path, "utf8");
   } catch {
     return null;
   }
 }
 async function exists6(path) {
   try {
-    await stat9(path);
+    await stat10(path);
     return true;
   } catch {
     return false;
@@ -5130,13 +5414,13 @@ import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 
 // src/openspec/inspector.ts
-import { readdir as readdir3, stat as stat10 } from "fs/promises";
-import { join as join21 } from "path";
+import { readdir as readdir4, stat as stat11 } from "fs/promises";
+import { join as join22 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join21(projectRoot, "openspec");
-  const changesPath = join21(openspecPath, "changes");
-  const legacyArchivePath = join21(openspecPath, "archive");
-  const changesArchivePath = join21(changesPath, "archive");
+  const openspecPath = join22(projectRoot, "openspec");
+  const changesPath = join22(openspecPath, "changes");
+  const legacyArchivePath = join22(openspecPath, "archive");
+  const changesArchivePath = join22(changesPath, "archive");
   return {
     exists: await exists7(openspecPath),
     changes: await listDirectories(changesPath, { exclude: ["archive"] }),
@@ -5144,13 +5428,13 @@ async function inspectOpenSpecProject(projectRoot) {
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join21(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join21(changePath, "tasks.md");
-  const specsPath = join21(changePath, "specs");
+  const changePath = join22(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join22(changePath, "tasks.md");
+  const specsPath = join22(changePath, "specs");
   return {
     changeId,
     exists: await exists7(changePath),
-    hasProposal: await exists7(join21(changePath, "proposal.md")),
+    hasProposal: await exists7(join22(changePath, "proposal.md")),
     hasTasks: await exists7(tasksPath),
     hasSpecs: await exists7(specsPath),
     tasksPath,
@@ -5159,7 +5443,7 @@ async function inspectOpenSpecChange(projectRoot, changeId) {
 }
 async function listDirectories(path, options = {}) {
   try {
-    const entries = await readdir3(path, { withFileTypes: true });
+    const entries = await readdir4(path, { withFileTypes: true });
     const excluded = new Set(options.exclude ?? []);
     return entries.filter((entry) => entry.isDirectory() && !excluded.has(entry.name)).map((entry) => entry.name);
   } catch {
@@ -5168,7 +5452,7 @@ async function listDirectories(path, options = {}) {
 }
 async function exists7(path) {
   try {
-    await stat10(path);
+    await stat11(path);
     return true;
   } catch {
     return false;
@@ -5351,13 +5635,13 @@ function escapeRegExp(value) {
 }
 
 // src/scanner/routes.ts
-import { readdir as readdir4, stat as stat11 } from "fs/promises";
-import { join as join22, relative as relative2, sep } from "path";
+import { readdir as readdir5, stat as stat12 } from "fs/promises";
+import { join as join23, relative as relative3, sep } from "path";
 async function scanRoutes(projectRoot) {
   const candidates = ["src/routes", "src/pages", "app", "pages"];
   const routes = [];
   for (const candidate of candidates) {
-    const root = join22(projectRoot, candidate);
+    const root = join23(projectRoot, candidate);
     if (!await exists8(root)) {
       continue;
     }
@@ -5366,8 +5650,8 @@ async function scanRoutes(projectRoot) {
         continue;
       }
       routes.push({
-        path: inferRoutePath(relative2(root, file)),
-        source: relative2(projectRoot, file).split(sep).join("/"),
+        path: inferRoutePath(relative3(root, file)),
+        source: relative3(projectRoot, file).split(sep).join("/"),
         inferred: true,
         confidence: "medium"
       });
@@ -5382,10 +5666,10 @@ function inferRoutePath(relativePath) {
   return `/${withoutIndex}`.replace(/\/+/g, "/");
 }
 async function listFiles(root) {
-  const entries = await readdir4(root, { withFileTypes: true });
+  const entries = await readdir5(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join22(root, entry.name);
+    const path = join23(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -5396,7 +5680,7 @@ async function listFiles(root) {
 }
 async function exists8(path) {
   try {
-    await stat11(path);
+    await stat12(path);
     return true;
   } catch {
     return false;
@@ -5553,9 +5837,9 @@ async function createCommandContext(command, options) {
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/update/check.ts
-import { mkdir as mkdir10, readFile as readFile17, writeFile } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile18, writeFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname10, join as join23 } from "path";
+import { dirname as dirname10, join as join24 } from "path";
 var DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
 function getFetUpdateCheckMode(env = process.env) {
   const value = env.FET_UPDATE_CHECK?.trim().toLowerCase();
@@ -5628,11 +5912,11 @@ function formatFetUpdateWarning(availability, language) {
 }
 function cachePath() {
   const home = process.env.FET_UPDATE_CHECK_CACHE_HOME?.trim() || homedir2();
-  return join23(home, ".fet", "update-check-cache.json");
+  return join24(home, ".fet", "update-check-cache.json");
 }
 async function readUpdateCheckCache() {
   try {
-    const raw = await readFile17(cachePath(), "utf8");
+    const raw = await readFile18(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
       return null;