@nick848/ft 0.1.0 → 0.1.1

package/dist/index.js

@@ -5,11 +5,11 @@ import { Command } from "commander";
 
 // src/cli/commands/init.ts
 import chalk2 from "chalk";
-import inquirer from "inquirer";
-import { execa as execa2 } from "execa";
+import inquirer2 from "inquirer";
+import { execa as execa3 } from "execa";
 
 // src/core/detector.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import path2 from "path";
 import { execa } from "execa";
 
@@ -43,6 +43,15 @@ function getRulesTemplatesDir() {
 function getLocalesDir() {
   return path.join(getPackageRoot(), "locales");
 }
+function getCursorCommandsTemplatesDir() {
+  return path.join(getPackageRoot(), "cursor-commands-templates");
+}
+function getSkillsTemplatesDir() {
+  return path.join(getPackageRoot(), "skills-templates");
+}
+function getScriptsDir() {
+  return path.join(getPackageRoot(), "scripts");
+}
 
 // src/core/detector.ts
 var KARPATHY_PATHS = [
@@ -70,14 +79,6 @@ function detectKarpathyRules(projectRoot = process.cwd()) {
   const templatesDir = getRulesTemplatesDir();
   return existsSync2(path2.join(templatesDir, "cursor.mdc"));
 }
-async function detectGitNexus() {
-  try {
-    const { stdout } = await execa("gitnexus", ["--version"]);
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
 function detectPlatformsInProject(projectRoot = process.cwd()) {
   const found = [];
   for (const [id, dir] of Object.entries(PLATFORM_DIRS)) {
@@ -135,6 +136,9 @@ function detectProjectMeta(projectRoot = process.cwd()) {
     scripts
   };
 }
+function isStdinTTY() {
+  return Boolean(process.stdin.isTTY);
+}
 function isStdoutTTY() {
   return Boolean(process.stdout.isTTY);
 }
@@ -144,19 +148,6 @@ function agentsMdHasPendingPlaceholders(projectRoot = process.cwd()) {
   const content = readFileSync2(agentsPath, "utf-8");
   return content.includes("[NEEDS LLM INPUT]");
 }
-function gitNexusGraphExists(projectRoot = process.cwd()) {
-  const graphDir = path2.join(projectRoot, ".gitnexus");
-  return existsSync2(graphDir);
-}
-function countGitNexusIndexFiles(projectRoot = process.cwd()) {
-  const graphDir = path2.join(projectRoot, ".gitnexus");
-  if (!existsSync2(graphDir)) return 0;
-  try {
-    return readdirSync(graphDir).length;
-  } catch {
-    return 0;
-  }
-}
 
 // src/core/config.ts
 import { cosmiconfig } from "cosmiconfig";
@@ -171,18 +162,18 @@ var DEFAULT_CONFIG = {
     auto_trigger_lines: 500,
     exclude_patterns: ["--json", "--format json", "--xml"]
   },
-  tools: ["cursor", "codex", "opencode"],
-  gitnexus: {
-    graph_path: ".gitnexus/",
-    auto_prompt_in_agents: true
-  }
+  figma: {
+    enabled: false,
+    configured: false
+  },
+  tools: ["cursor", "codex", "opencode"]
 };
 function mergeConfig(partial) {
   return {
     ...DEFAULT_CONFIG,
     ...partial,
     rtk: { ...DEFAULT_CONFIG.rtk, ...partial?.rtk },
-    gitnexus: { ...DEFAULT_CONFIG.gitnexus, ...partial?.gitnexus },
+    figma: { ...DEFAULT_CONFIG.figma, ...partial?.figma },
     tools: partial?.tools ?? DEFAULT_CONFIG.tools
   };
 }
@@ -226,13 +217,7 @@ import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameS
 import path4 from "path";
 
 // src/core/template.ts
-function getGitNexusCondition(lang) {
-  if (lang === "en") {
-    return "If GitNexus is installed in this project, AI **must prioritize** GitNexus MCP tools (e.g. `gitnexus_get_symbol`) for code scanning and dependency analysis. If not installed, ignore this rule.";
-  }
-  return "\u5982\u679C\u5F53\u524D\u5DE5\u7A0B\u5DF2\u5B89\u88C5 GitNexus\uFF0CAI \u5728\u8FDB\u884C\u4EE3\u7801\u626B\u63CF\u548C\u5206\u6790\u65F6**\u5FC5\u987B\u4F18\u5148\u4F7F\u7528** GitNexus MCP \u5DE5\u5177\uFF08\u5982 `gitnexus_get_symbol`\uFF09\u83B7\u53D6\u7B26\u53F7\u7EA7\u4F9D\u8D56\u5173\u7CFB\u3002\u82E5\u672A\u5B89\u88C5\uFF0C\u8BF7\u5FFD\u7565\u6B64\u6761\u3002";
-}
-function buildAgentsTemplateData(meta, lang) {
+function buildAgentsTemplateData(meta) {
   return {
     projectName: meta.name,
     packageManager: meta.packageManager,
@@ -240,8 +225,7 @@ function buildAgentsTemplateData(meta, lang) {
     language: meta.language,
     monorepo: meta.monorepo,
     workspaces: meta.workspaces,
-    scripts: meta.scripts,
-    gitnexus_condition: getGitNexusCondition(lang)
+    scripts: meta.scripts
   };
 }
 
@@ -251,7 +235,7 @@ function renderAgentsMd(meta, lang) {
   const templatePath = path4.join(getTemplatesDir(), templateName);
   const source = readFileSync4(templatePath, "utf-8");
   const template = Handlebars.compile(source);
-  const data = buildAgentsTemplateData(meta, lang);
+  const data = buildAgentsTemplateData(meta);
   return template(data);
 }
 function generateAgentsMd(meta, lang, projectRoot = process.cwd()) {
@@ -263,30 +247,6 @@ function generateAgentsMd(meta, lang, projectRoot = process.cwd()) {
   const content = renderAgentsMd(meta, lang);
   writeFileSync2(agentsPath, content, "utf-8");
 }
-function updateGraphTimestampInAgents(projectRoot = process.cwd(), timestamp) {
-  const agentsPath = path4.join(projectRoot, "AGENTS.md");
-  if (!existsSync4(agentsPath)) return;
-  const ts = timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-  let content = readFileSync4(agentsPath, "utf-8");
-  const marker = "\u56FE\u8C31\u6700\u540E\u5237\u65B0\u65F6\u95F4";
-  const enMarker = "Graph last refreshed";
-  const isEnglish = content.includes("## AI Working Guide");
-  const line = isEnglish ? `- ${enMarker}: ${ts}` : `- ${marker}: ${ts}`;
-  const regex = /- (图谱最后刷新时间|Graph last refreshed): .+/;
-  if (regex.test(content)) {
-    content = content.replace(regex, line);
-  } else if (content.includes("## AI \u5DE5\u4F5C\u6307\u5357") || isEnglish) {
-    const sectionRegex = /(## AI (工作指南|Working Guide)\n)/;
-    content = content.replace(sectionRegex, `$1${line}
-`);
-  } else {
-    content += `
-## AI \u5DE5\u4F5C\u6307\u5357
-${line}
-`;
-  }
-  writeFileSync2(agentsPath, content, "utf-8");
-}
 
 // src/core/i18n.ts
 import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
@@ -315,68 +275,13 @@ function tf(key, lang, vars) {
 }
 
 // src/adapters/index.ts
-import { homedir } from "os";
 import path6 from "path";
-import {
-  readFileSync as readFileSync6,
-  writeFileSync as writeFileSync3,
-  mkdirSync as mkdirSync2,
-  existsSync as existsSync6,
-  copyFileSync
-} from "fs";
-import deepmerge from "deepmerge";
-var GITNEXUS_SNIPPET = {
-  gitnexus: {
-    command: "gitnexus",
-    args: ["mcp"],
-    disabled: false
-  }
-};
-function readJsonFile(filePath) {
-  if (!existsSync6(filePath)) {
-    return { mcpServers: {} };
-  }
-  const raw = readFileSync6(filePath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { mcpServers: {} };
-  }
-}
-function writeJsonFile(filePath, data) {
-  const dir = path6.dirname(filePath);
-  if (!existsSync6(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  writeFileSync3(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
-}
-function ensureMcpServersShape(config) {
-  if (!config.mcpServers || typeof config.mcpServers !== "object") {
-    config.mcpServers = {};
-  }
-  return config;
-}
-function createAdapter(id, rulesTargetPath, rulesTemplateName, mcpConfigPath) {
+import { mkdirSync as mkdirSync2, existsSync as existsSync6, copyFileSync } from "fs";
+function createAdapter(id, rulesTargetPath, rulesTemplateName) {
   return {
     id,
     rulesTargetPath,
     rulesTemplateName,
-    mcpConfigPath,
-    getGitNexusMcpEntry() {
-      return { ...GITNEXUS_SNIPPET };
-    },
-    mergeGitNexusMcp(config) {
-      const base = ensureMcpServersShape({ ...config });
-      const servers = base.mcpServers;
-      if (servers.gitnexus) {
-        return base;
-      }
-      return deepmerge(base, { mcpServers: GITNEXUS_SNIPPET });
-    },
-    hasGitNexusMcp(config) {
-      const servers = config.mcpServers;
-      return Boolean(servers?.gitnexus);
-    },
     injectRules(projectRoot) {
       const target = path6.join(projectRoot, rulesTargetPath);
       const source = path6.join(getRulesTemplatesDir(), rulesTemplateName);
@@ -385,41 +290,23 @@ function createAdapter(id, rulesTargetPath, rulesTemplateName, mcpConfigPath) {
         mkdirSync2(dir, { recursive: true });
       }
       copyFileSync(source, target);
-    },
-    async configureMcp() {
-      const configPath = mcpConfigPath;
-      const snippet = JSON.stringify(GITNEXUS_SNIPPET, null, 2);
-      try {
-        const existing = readJsonFile(configPath);
-        if (this.hasGitNexusMcp(existing)) {
-          return { success: true, path: configPath, snippet };
-        }
-        const merged = this.mergeGitNexusMcp(existing);
-        writeJsonFile(configPath, merged);
-        return { success: true, path: configPath, snippet };
-      } catch {
-        return { success: false, path: configPath, snippet };
-      }
     }
   };
 }
 var cursorAdapter = createAdapter(
   "cursor",
   ".cursor/rules/karpathy-guidelines.mdc",
-  "cursor.mdc",
-  path6.join(homedir(), ".cursor", "mcp.json")
+  "cursor.mdc"
 );
 var codexAdapter = createAdapter(
   "codex",
   ".codex/rules/karpathy-guidelines.md",
-  "codex.md",
-  path6.join(homedir(), ".codex", "mcp.json")
+  "codex.md"
 );
 var opencodeAdapter = createAdapter(
   "opencode",
   ".opencode/rules/karpathy-guidelines.md",
-  "opencode.md",
-  path6.join(homedir(), ".config", "opencode", "mcp.json")
+  "opencode.md"
 );
 var adapters = {
   cursor: cursorAdapter,
@@ -430,38 +317,419 @@ function getAdaptersForPlatforms(platforms) {
   return platforms.map((p) => adapters[p]);
 }
 
-// src/adapters/mcp-setup.ts
-import chalk from "chalk";
-import readline from "readline";
-async function configureMcpForAdapters(adapterList, lang) {
-  for (const adapter of adapterList) {
-    const result = await adapter.configureMcp();
-    if (result.success) {
-      console.log(chalk.green(tf("mcp.writeSuccess", lang, { path: result.path })));
+// src/adapters/cursor-commands.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readdirSync
+} from "fs";
+import path7 from "path";
+function injectCursorSlashCommands(projectRoot = process.cwd()) {
+  const sourceDir = getCursorCommandsTemplatesDir();
+  const targetDir = path7.join(projectRoot, ".cursor", "commands");
+  if (!existsSync7(sourceDir)) {
+    throw new Error(`Cursor command templates not found: ${sourceDir}`);
+  }
+  mkdirSync3(targetDir, { recursive: true });
+  const files = readdirSync(sourceDir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    copyFileSync2(path7.join(sourceDir, file), path7.join(targetDir, file));
+  }
+  return files.length;
+}
+
+// src/adapters/visual-skills.ts
+import {
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync2,
+  statSync
+} from "fs";
+import path8 from "path";
+var SKILL_NAME = "visual-fidelity";
+function copyDirRecursive(source, target) {
+  mkdirSync4(target, { recursive: true });
+  let count = 0;
+  for (const entry of readdirSync2(source)) {
+    const srcPath = path8.join(source, entry);
+    const destPath = path8.join(target, entry);
+    if (statSync(srcPath).isDirectory()) {
+      count += copyDirRecursive(srcPath, destPath);
     } else {
-      await promptManualMcpConfig(adapter, lang, result.path, result.snippet);
-    }
-  }
-}
-async function promptManualMcpConfig(_adapter, lang, configPath, snippet) {
-  const border = "\u2550".repeat(60);
-  console.log(chalk.yellow(`
-${border}`));
-  console.log(chalk.yellow.bold(tf("mcp.manualTitle", lang, { path: configPath })));
-  console.log(chalk.cyan(snippet));
-  console.log(chalk.yellow(`${border}
-`));
-  console.log(chalk.gray(tf("mcp.pressKey", lang)));
-  await new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    process.stdin.setRawMode?.(true);
-    process.stdin.resume();
-    process.stdin.once("data", () => {
-      rl.close();
-      process.stdin.setRawMode?.(false);
-      resolve();
-    });
+      copyFileSync3(srcPath, destPath);
+      count += 1;
+    }
+  }
+  return count;
+}
+function injectVisualFidelitySkill(projectRoot = process.cwd()) {
+  const sourceDir = path8.join(getSkillsTemplatesDir(), SKILL_NAME);
+  const targetDir = path8.join(projectRoot, ".cursor", "skills", SKILL_NAME);
+  if (!existsSync8(sourceDir)) {
+    throw new Error(`Visual fidelity skill templates not found: ${sourceDir}`);
+  }
+  return copyDirRecursive(sourceDir, targetDir);
+}
+function getVisualFidelitySkillPath(projectRoot) {
+  return path8.join(projectRoot, ".cursor", "skills", SKILL_NAME, "SKILL.md");
+}
+
+// src/core/visual-spec.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync3
+} from "fs";
+import path9 from "path";
+function parseFigmaUrl(url) {
+  const normalized = url.trim();
+  const match = /figma\.com\/(?:file|design)\/([a-zA-Z0-9]+)/i.exec(normalized) ?? /figma\.com\/(?:file|design)\/([a-zA-Z0-9]+)/i.exec(normalized);
+  if (!match?.[1]) return null;
+  const fileKey = match[1];
+  const nodeParam = /[?&]node-id=([^&\s)]+)/i.exec(normalized);
+  const nodeId = nodeParam?.[1]?.replace(/-/g, ":");
+  return nodeId ? { fileKey, nodeId } : { fileKey };
+}
+function extractFigmaLinks(text) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n")) {
+    const urlMatch = /(https?:\/\/[^\s)]+)/g;
+    let m;
+    while ((m = urlMatch.exec(line)) !== null) {
+      const url = m[1];
+      if (!url.includes("figma.com")) continue;
+      if (seen.has(url)) continue;
+      seen.add(url);
+      const parsed = parseFigmaUrl(url);
+      const label = line.replace(url, "").replace(/^[-*•\s]+/, "").trim();
+      links.push({
+        url,
+        fileKey: parsed?.fileKey,
+        nodeId: parsed?.nodeId,
+        label: label || void 0
+      });
+    }
+  }
+  return links;
+}
+function extractVisualDesignSection(agentsContent, lang) {
+  const headings = lang === "en" ? ["Visual Design", "Design"] : ["\u89C6\u89C9\u7A3F", "\u8BBE\u8BA1\u7A3F"];
+  for (const heading of headings) {
+    const regex = new RegExp(`## ${heading}[\\s\\n]+([\\s\\S]*?)(?=\\n## |$)`, "m");
+    const match = agentsContent.match(regex);
+    const section = match?.[1]?.trim() ?? "";
+    if (section && !section.includes("[NEEDS LLM INPUT]")) {
+      return section;
+    }
+  }
+  return "";
+}
+function getFtDir(projectRoot) {
+  return path9.join(projectRoot, ".ft");
+}
+function getVisualSpecPath(projectRoot) {
+  return path9.join(getFtDir(projectRoot), "visual-spec.md");
+}
+function getVisualChecklistPath(projectRoot) {
+  return path9.join(getFtDir(projectRoot), "visual-checklist.json");
+}
+function loadVisualSpecTemplate() {
+  const templatePath = path9.join(getTemplatesDir(), "visual-spec.md");
+  return readFileSync6(templatePath, "utf-8");
+}
+function defaultChecklist(frame = "TBD") {
+  return {
+    version: 1,
+    frame,
+    items: []
+  };
+}
+function readVisualChecklist(projectRoot) {
+  const checklistPath = getVisualChecklistPath(projectRoot);
+  if (!existsSync9(checklistPath)) {
+    return defaultChecklist();
+  }
+  try {
+    return JSON.parse(readFileSync6(checklistPath, "utf-8"));
+  } catch {
+    return defaultChecklist();
+  }
+}
+function writeVisualChecklist(projectRoot, checklist) {
+  const ftDir = getFtDir(projectRoot);
+  mkdirSync5(ftDir, { recursive: true });
+  writeFileSync3(
+    getVisualChecklistPath(projectRoot),
+    `${JSON.stringify(checklist, null, 2)}
+`,
+    "utf-8"
+  );
+}
+function tokenToChecklistItem(token) {
+  return {
+    id: token.id,
+    category: token.category,
+    description: token.description,
+    designValue: token.value,
+    cssVariable: token.cssVariable,
+    status: "pending"
+  };
+}
+function mergeTokensIntoChecklist(checklist, tokens, frame, nodeId) {
+  const existingById = new Map(checklist.items.map((item) => [item.id, item]));
+  const mergedItems = tokens.map((token) => {
+    const existing = existingById.get(token.id);
+    if (existing?.status === "passed") {
+      return existing;
+    }
+    return tokenToChecklistItem(token);
+  });
+  for (const item of checklist.items) {
+    if (!mergedItems.some((m) => m.id === item.id)) {
+      mergedItems.push(item);
+    }
+  }
+  return {
+    ...checklist,
+    frame: frame ?? checklist.frame,
+    figmaNodeId: nodeId ?? checklist.figmaNodeId,
+    items: mergedItems
+  };
+}
+function renderTokenRows(tokens) {
+  if (tokens.length === 0) {
+    return "| TBD | TBD | TBD | TBD |";
+  }
+  return tokens.map(
+    (t2) => `| ${t2.id} | ${t2.value} | ${t2.cssVariable ?? "\u2014"} | ${t2.source ?? "figma"} |`
+  ).join("\n");
+}
+function renderDesignSources(links, lang) {
+  if (links.length === 0) {
+    return lang === "en" ? "- TBD \u2014 add Figma/Lanhu links to AGENTS.md Visual Design section" : "- TBD \u2014 \u8BF7\u5728 AGENTS.md\u300C\u89C6\u89C9\u7A3F\u300D\u7AE0\u8282\u8865\u5145 Figma / \u84DD\u6E56\u94FE\u63A5";
+  }
+  return links.map((link) => {
+    const parts = [link.url];
+    if (link.fileKey) parts.push(`fileKey: \`${link.fileKey}\``);
+    if (link.nodeId) parts.push(`nodeId: \`${link.nodeId}\``);
+    if (link.label) parts.unshift(`**${link.label}** \u2014`);
+    return `- ${parts.join(" \xB7 ")}`;
+  }).join("\n");
+}
+function writeVisualSpec(projectRoot, links, tokens, lang) {
+  const ftDir = getFtDir(projectRoot);
+  mkdirSync5(ftDir, { recursive: true });
+  const template = loadVisualSpecTemplate();
+  const content = template.replace("{{designSources}}", renderDesignSources(links, lang)).replace("{{tokenRows}}", renderTokenRows(tokens));
+  writeFileSync3(getVisualSpecPath(projectRoot), content, "utf-8");
+}
+function ensureVisualSpec(projectRoot, lang, designSection, tokens = [], primaryLink) {
+  const links = extractFigmaLinks(designSection);
+  const specExists = existsSync9(getVisualSpecPath(projectRoot));
+  const checklist = readVisualChecklist(projectRoot);
+  const frameName = primaryLink?.label ?? primaryLink?.nodeId ?? checklist.frame ?? "TBD";
+  const mergedChecklist = mergeTokensIntoChecklist(
+    checklist,
+    tokens,
+    frameName,
+    primaryLink?.nodeId
+  );
+  writeVisualSpec(projectRoot, links, tokens, lang);
+  writeVisualChecklist(projectRoot, mergedChecklist);
+  return {
+    specPath: getVisualSpecPath(projectRoot),
+    checklistPath: getVisualChecklistPath(projectRoot),
+    created: !specExists,
+    tokenCount: tokens.length,
+    linkCount: links.length
+  };
+}
+function countChecklistByStatus(checklist) {
+  const passed = checklist.items.filter((i) => i.status === "passed").length;
+  const failed = checklist.items.filter((i) => i.status === "failed").length;
+  const pending = checklist.items.filter((i) => i.status === "pending").length;
+  return { passed, pending, failed, total: checklist.items.length };
+}
+
+// src/core/visual-verify.ts
+import {
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync4
+} from "fs";
+import path10 from "path";
+import { execa as execa2 } from "execa";
+var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+function getVisualVerifyConfigPath(projectRoot) {
+  return path10.join(getFtDir(projectRoot), "visual-verify.json");
+}
+function getVisualBaselinesDir(projectRoot) {
+  return path10.join(getFtDir(projectRoot), "visual-baselines");
+}
+function readVisualVerifyConfig(projectRoot) {
+  const configPath = getVisualVerifyConfigPath(projectRoot);
+  if (!existsSync10(configPath)) return null;
+  try {
+    return JSON.parse(readFileSync7(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function ensureVisualVerifyConfig(projectRoot) {
+  const ftDir = getFtDir(projectRoot);
+  mkdirSync6(ftDir, { recursive: true });
+  mkdirSync6(getVisualBaselinesDir(projectRoot), { recursive: true });
+  const configPath = getVisualVerifyConfigPath(projectRoot);
+  if (!existsSync10(configPath)) {
+    const templatePath = path10.join(getTemplatesDir(), "visual-verify.json");
+    writeFileSync4(configPath, readFileSync7(templatePath, "utf-8"), "utf-8");
+  }
+  return configPath;
+}
+function resolveProjectDependency(projectRoot, packageName) {
+  const pkgPath = path10.join(projectRoot, "node_modules", packageName, "package.json");
+  return existsSync10(pkgPath) ? path10.join(projectRoot, "node_modules", packageName) : null;
+}
+function hasVisualDiffDependencies(projectRoot) {
+  return resolveProjectDependency(projectRoot, "playwright") !== null && resolveProjectDependency(projectRoot, "pixelmatch") !== null && resolveProjectDependency(projectRoot, "pngjs") !== null;
+}
+async function runVisualDiff(projectRoot) {
+  const scriptPath = path10.join(getScriptsDir(), "visual-diff.mjs");
+  if (!existsSync10(scriptPath)) {
+    return { exitCode: 1, report: null, stdout: "" };
+  }
+  const result = await execa2("node", [scriptPath], {
+    cwd: projectRoot,
+    reject: false
   });
+  let report = null;
+  const jsonLine = result.stdout.split("\n").map((line) => line.trim()).find((line) => line.startsWith("{") && line.includes('"results"'));
+  if (jsonLine) {
+    try {
+      report = JSON.parse(jsonLine);
+    } catch {
+      report = null;
+    }
+  }
+  return {
+    exitCode: result.exitCode ?? 1,
+    report,
+    stdout: [result.stdout, result.stderr].filter(Boolean).join("\n")
+  };
+}
+function formatVerifyConfigSummary(config, lang) {
+  const lines = config.screens.map(
+    (s) => `  - ${s.id}: ${config.baseUrl}${s.path} \u2194 ${s.baseline} (${s.viewport?.width ?? DEFAULT_VIEWPORT.width}\xD7${s.viewport?.height ?? DEFAULT_VIEWPORT.height})`
+  );
+  return lines.join("\n") || (lang === "en" ? "  (no screens configured)" : "  \uFF08\u672A\u914D\u7F6E\u9875\u9762\uFF09");
+}
+
+// src/adapters/figma-mcp.ts
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync5
+} from "fs";
+import path11 from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+var FIGMA_SERVER_ID = "figma-developer-mcp";
+var FIGMA_DOCS_URL = "https://www.figma.com/developers/api#access-tokens";
+function getMcpPath(projectRoot) {
+  return path11.join(projectRoot, ".cursor", "mcp.json");
+}
+function readMcpJson(projectRoot) {
+  const mcpPath = getMcpPath(projectRoot);
+  if (!existsSync11(mcpPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    return JSON.parse(readFileSync8(mcpPath, "utf-8"));
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function writeMcpJson(projectRoot, config) {
+  const cursorDir = path11.join(projectRoot, ".cursor");
+  mkdirSync7(cursorDir, { recursive: true });
+  writeFileSync5(getMcpPath(projectRoot), `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function buildFigmaMcpServerEntry(apiKey) {
+  const args = ["-y", "figma-developer-mcp", "--stdio"];
+  const env = { FIGMA_API_KEY: apiKey };
+  if (process.platform === "win32") {
+    return {
+      command: "cmd",
+      args: ["/c", "npx", ...args],
+      env
+    };
+  }
+  return {
+    command: "npx",
+    args,
+    env
+  };
+}
+function mergeFigmaMcpConfig(projectRoot, apiKey) {
+  const existing = readMcpJson(projectRoot);
+  const servers = existing.mcpServers ?? existing.servers ?? {};
+  const entry = buildFigmaMcpServerEntry(apiKey);
+  const next = {
+    ...existing,
+    mcpServers: {
+      ...servers,
+      [FIGMA_SERVER_ID]: entry
+    }
+  };
+  delete next.servers;
+  writeMcpJson(projectRoot, next);
+}
+function isFigmaMcpConfigured(projectRoot = process.cwd()) {
+  const mcpPath = getMcpPath(projectRoot);
+  if (!existsSync11(mcpPath)) {
+    return false;
+  }
+  const content = readFileSync8(mcpPath, "utf-8");
+  return content.includes(FIGMA_SERVER_ID) || content.includes("figma-developer-mcp") || content.includes("FIGMA_API_KEY");
+}
+async function setupFigmaMcp(projectRoot, lang) {
+  console.log("");
+  console.log(t("init.figmaIntro", lang));
+  console.log(t("init.figmaDocsHint", lang));
+  console.log(`  ${FIGMA_DOCS_URL}`);
+  console.log("");
+  const { configure } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "configure",
+      message: t("init.figmaConfigureQuestion", lang),
+      default: true
+    }
+  ]);
+  if (!configure) {
+    console.log(chalk.yellow(t("init.figmaSkipped", lang)));
+    return { enabled: false, configured: false };
+  }
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: t("init.figmaApiKeyQuestion", lang),
+      mask: "*",
+      validate: (value) => value.trim().length > 0 ? true : t("init.figmaApiKeyRequired", lang)
+    }
+  ]);
+  mergeFigmaMcpConfig(projectRoot, apiKey.trim());
+  console.log(chalk.green(tf("init.figmaConfigured", lang, { path: ".cursor/mcp.json" })));
+  console.log(chalk.yellow(t("init.figmaGitignoreHint", lang)));
+  return { enabled: true, configured: true };
 }
 
 // src/cli/commands/init.ts
@@ -474,7 +742,7 @@ async function selectPlatforms(mode, lang) {
     if (detected.length > 0) return detected;
     return ["cursor", "codex", "opencode"];
   }
-  const { platforms } = await inquirer.prompt([
+  const { platforms } = await inquirer2.prompt([
     {
       type: "checkbox",
       name: "platforms",
@@ -490,7 +758,7 @@ async function selectPlatforms(mode, lang) {
   return platforms;
 }
 async function selectInjectMode(lang) {
-  const { mode } = await inquirer.prompt([
+  const { mode } = await inquirer2.prompt([
     {
       type: "list",
       name: "mode",
@@ -517,11 +785,6 @@ async function runInit(options) {
     console.error(chalk2.red(t("error.karpathyMissing", language)));
     process.exit(1);
   }
-  const gitnexusVersion = await detectGitNexus();
-  const gitnexusInstalled = Boolean(gitnexusVersion);
-  if (!gitnexusInstalled) {
-    console.log(chalk2.gray(t("hint.gitnexusOptional", language)));
-  }
   const injectMode = await selectInjectMode(language);
   const selectedPlatforms = await selectPlatforms(injectMode, language);
   const adapterList = getAdaptersForPlatforms(selectedPlatforms);
@@ -529,8 +792,26 @@ async function runInit(options) {
     adapter.injectRules(projectRoot);
     console.log(chalk2.green(tf("init.rulesInjected", language, { path: adapter.rulesTargetPath })));
   }
-  if (gitnexusInstalled) {
-    await configureMcpForAdapters(adapterList, language);
+  if (selectedPlatforms.includes("cursor")) {
+    const commandCount = injectCursorSlashCommands(projectRoot);
+    console.log(
+      chalk2.green(tf("init.cursorCommandsInjected", language, { count: String(commandCount) }))
+    );
+    const skillFileCount = injectVisualFidelitySkill(projectRoot);
+    console.log(
+      chalk2.green(tf("init.visualSkillInjected", language, { count: String(skillFileCount) }))
+    );
+    ensureVisualSpec(projectRoot, language, "");
+    ensureVisualVerifyConfig(projectRoot);
+    console.log(chalk2.green(t("init.visualSpecScaffolded", language)));
+  }
+  let figmaConfig = existingConfig.figma ?? { enabled: false, configured: false };
+  if (selectedPlatforms.includes("cursor")) {
+    if (isFigmaMcpConfigured(projectRoot)) {
+      figmaConfig = { enabled: true, configured: true };
+    } else {
+      figmaConfig = await setupFigmaMcp(projectRoot, language);
+    }
   }
   const meta = detectProjectMeta(projectRoot);
   generateAgentsMd(meta, language, projectRoot);
@@ -538,28 +819,29 @@ async function runInit(options) {
   const config = mergeConfig({
     ...existingConfig,
     language,
+    figma: figmaConfig,
     tools: selectedPlatforms
   });
   writeDefaultConfig(projectRoot, config);
   console.log(chalk2.blue(t("init.runningComet", language)));
-  await execa2("comet", ["init"], { stdio: "inherit", cwd: projectRoot });
+  await execa3("comet", ["init"], { stdio: "inherit", cwd: projectRoot });
   console.log(chalk2.green.bold(t("init.success", language)));
   console.log(chalk2.cyan(t("init.nextStep", language)));
 }
 
 // src/cli/commands/update.ts
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 async function runUpdate() {
-  await execa3("npm", ["update", "-g", "@nick848/ft"], { stdio: "inherit" });
+  await execa4("npm", ["update", "-g", "@nick848/ft"], { stdio: "inherit" });
 }
 
 // src/cli/commands/version.ts
-import { readFileSync as readFileSync7 } from "fs";
-import path7 from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import path12 from "path";
 function getFtVersion() {
   try {
-    const pkgPath = path7.join(getPackageRoot(), "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    const pkgPath = path12.join(getPackageRoot(), "package.json");
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -568,47 +850,42 @@ function getFtVersion() {
 async function runVersion() {
   const ftVersion = getFtVersion();
   const cometVersion = await detectComet();
-  const gitnexusVersion = await detectGitNexus();
-  console.log(`FT:       ${ftVersion}`);
-  console.log(`Comet:    ${cometVersion ?? "not installed"}`);
-  console.log(`GitNexus: ${gitnexusVersion ?? "not installed"}`);
+  console.log(`FT:    ${ftVersion}`);
+  console.log(`Comet: ${cometVersion ?? "not installed"}`);
 }
 
 // src/cli/commands/help.ts
 function printHelp() {
   console.log(`
-FT (Frontend Toolkit) \u2014 CLI orchestration for Comet, Karpathy rules, and GitNexus
+FT (Frontend Toolkit) \u2014 CLI orchestration for Comet and Karpathy rules
 
 Usage:
   ft init [--lang en|zh-CN]   Full project initialization pipeline
   ft update                   Update @nick848/ft globally
-  ft version                  Show FT, Comet, and GitNexus versions
+  ft version                  Show FT and Comet versions
   ft help                     Show this help
   ft slash <command> [args]   Run IDE slash command (internal)
 
 Slash commands (use via IDE, maps to ft slash):
-  fill-context    Output prompt recipe to fill AGENTS.md
-  open            Comet open (passthrough)
-  design          Comet design (passthrough)
-  build           Comet build (passthrough)
-  verify          Comet verify (passthrough)
-  archive         Comet archive (passthrough)
-  hotfix          Comet hotfix (passthrough)
-  tweak           Comet tweak (passthrough)
-  graph-setup     GitNexus install guide + MCP retry
-  graph-init      gitnexus analyze
-  graph-refresh   gitnexus analyze --force
-  graph-handoff   Graph summary + prompt + AGENTS timestamp
-  graph-status    Check GitNexus installation and graph state
+  fill-context          Output prompt recipe to fill AGENTS.md
+  open                  Comet open (passthrough)
+  design                Comet design (passthrough)
+  build                 Comet build (passthrough)
+  verify                Comet verify (passthrough)
+  archive               Comet archive (passthrough)
+  hotfix                Comet hotfix (passthrough)
+  tweak                 Comet tweak (passthrough)
+  sync-cursor-commands  Reinstall Cursor slash commands
+  visual-tools-install  Install playwright, pixelmatch, pngjs for pixel diff
 `);
 }
 
 // src/cli/commands/slash.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 
 // src/slash/fill-context.ts
-import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
+import path13 from "path";
 var PLACEHOLDER = "[NEEDS LLM INPUT]";
 var SECTION_HINTS = {
   "\u7ED3\u6784": { zh: "\u8BF7\u904D\u5386 src/ \u751F\u6210\u6811\u5F62\u76EE\u5F55\u7ED3\u6784", en: "Traverse src/ and produce a tree directory structure" },
@@ -616,7 +893,19 @@ var SECTION_HINTS = {
   "\u89C4\u8303": { zh: "\u8BF7\u6839\u636E .eslintrc / prettier \u7B49\u914D\u7F6E\u6587\u4EF6\u603B\u7ED3\u4EE3\u7801\u89C4\u8303", en: "Summarize code conventions from eslint/prettier configs" },
   "Conventions": { zh: "\u8BF7\u6839\u636E .eslintrc / prettier \u7B49\u914D\u7F6E\u6587\u4EF6\u603B\u7ED3\u4EE3\u7801\u89C4\u8303", en: "Summarize code conventions from eslint/prettier configs" },
   "\u8DEF\u7531": { zh: "\u8BF7\u6839\u636E\u8DEF\u7531\u914D\u7F6E\u6587\u4EF6\u5217\u51FA\u4E3B\u8981\u8DEF\u7531", en: "List main routes from routing config" },
-  "Routing": { zh: "\u8BF7\u6839\u636E\u8DEF\u7531\u914D\u7F6E\u6587\u4EF6\u5217\u51FA\u4E3B\u8981\u8DEF\u7531", en: "List main routes from routing config" }
+  "Routing": { zh: "\u8BF7\u6839\u636E\u8DEF\u7531\u914D\u7F6E\u6587\u4EF6\u5217\u51FA\u4E3B\u8981\u8DEF\u7531", en: "List main routes from routing config" },
+  "\u89C6\u89C9\u7A3F": {
+    zh: "\u8BF7\u586B\u5199 Figma / \u84DD\u6E56\u7B49\u89C6\u89C9\u7A3F\u94FE\u63A5\uFF0C\u542B frame \u6216 node-id\uFF1B\u5982\u6709\u8BBE\u8BA1\u89C4\u8303\u4E00\u5E76\u8BF4\u660E",
+    en: "Add Figma / Lanhu design links with frame or node-id; include design tokens if any"
+  },
+  "Visual Design": {
+    zh: "\u8BF7\u586B\u5199 Figma / \u84DD\u6E56\u7B49\u89C6\u89C9\u7A3F\u94FE\u63A5\uFF0C\u542B frame \u6216 node-id\uFF1B\u5982\u6709\u8BBE\u8BA1\u89C4\u8303\u4E00\u5E76\u8BF4\u660E",
+    en: "Add Figma / Lanhu design links with frame or node-id; include design tokens if any"
+  },
+  "Design": {
+    zh: "\u8BF7\u586B\u5199 Figma / \u84DD\u6E56\u7B49\u89C6\u89C9\u7A3F\u94FE\u63A5\uFF0C\u542B frame \u6216 node-id\uFF1B\u5982\u6709\u8BBE\u8BA1\u89C4\u8303\u4E00\u5E76\u8BF4\u660E",
+    en: "Add Figma / Lanhu design links with frame or node-id; include design tokens if any"
+  }
 };
 function extractSections(content) {
   const lines = content.split("\n");
@@ -641,16 +930,16 @@ function findSectionInBackup(section, backup) {
 }
 async function runFillContext(config) {
   const projectRoot = process.cwd();
-  const agentsPath = path8.join(projectRoot, "AGENTS.md");
+  const agentsPath = path13.join(projectRoot, "AGENTS.md");
   const lang = config.language;
-  if (!existsSync7(agentsPath)) {
+  if (!existsSync12(agentsPath)) {
     console.log(t("fillContext.noAgents", lang));
     return;
   }
-  const agentsContent = readFileSync8(agentsPath, "utf-8");
+  const agentsContent = readFileSync10(agentsPath, "utf-8");
   const placeholders = extractSections(agentsContent);
-  const backupPath = path8.join(projectRoot, "AGENTS-BAK.md");
-  const backupContent = existsSync7(backupPath) ? readFileSync8(backupPath, "utf-8") : "";
+  const backupPath = path13.join(projectRoot, "AGENTS-BAK.md");
+  const backupContent = existsSync12(backupPath) ? readFileSync10(backupPath, "utf-8") : "";
   const langLabel = lang === "en" ? "English" : "\u7B80\u4F53\u4E2D\u6587";
   console.log(`# ${t("fillContext.title", lang)}
 `);
@@ -687,8 +976,464 @@ async function runFillContext(config) {
   }
 }
 
+// src/slash/build.ts
+import { readFileSync as readFileSync12, existsSync as existsSync14 } from "fs";
+import path15 from "path";
+import chalk3 from "chalk";
+import inquirer3 from "inquirer";
+
+// src/adapters/figma-api.ts
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import path14 from "path";
+var FIGMA_SERVER_ID2 = "figma-developer-mcp";
+function readFigmaApiKeyFromMcp(projectRoot) {
+  const mcpPath = path14.join(projectRoot, ".cursor", "mcp.json");
+  if (!existsSync13(mcpPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync11(mcpPath, "utf-8"));
+    const servers = raw.mcpServers ?? raw.servers ?? {};
+    const figma = servers[FIGMA_SERVER_ID2];
+    const key = figma?.env?.FIGMA_API_KEY;
+    return key?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function rgbaToHex(color) {
+  const toByte = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0");
+  const alpha = color.a ?? 1;
+  if (alpha < 1) {
+    return `rgba(${Math.round(color.r * 255)}, ${Math.round(color.g * 255)}, ${Math.round(color.b * 255)}, ${alpha.toFixed(2)})`;
+  }
+  return `#${toByte(color.r)}${toByte(color.g)}${toByte(color.b)}`.toUpperCase();
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
+}
+function extractColorTokens(node, tokens, seen) {
+  if (!node.fills?.length) return;
+  for (const fill of node.fills) {
+    if (fill.type !== "SOLID" || !fill.color) continue;
+    const hex = rgbaToHex(fill.color);
+    const base = slugify(node.name ?? "color") || "fill";
+    const id = `color-${base}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    tokens.push({
+      id,
+      category: "color",
+      description: `Fill color: ${node.name ?? "unnamed"}`,
+      value: hex,
+      cssVariable: `--color-${base}`,
+      source: "figma-api"
+    });
+  }
+}
+function extractTypographyTokens(node, tokens, seen) {
+  if (node.type !== "TEXT" || !node.style) return;
+  const { fontFamily, fontSize, fontWeight, lineHeightPx } = node.style;
+  if (!fontSize) return;
+  const base = slugify(node.name ?? "text") || "text";
+  const id = `typography-${base}`;
+  if (seen.has(id)) return;
+  seen.add(id);
+  const parts = [
+    fontSize ? `${fontSize}px` : null,
+    fontWeight ? `weight ${fontWeight}` : null,
+    fontFamily ?? null,
+    lineHeightPx ? `line-height ${lineHeightPx}px` : null
+  ].filter(Boolean);
+  tokens.push({
+    id,
+    category: "typography",
+    description: `Text: ${node.name ?? node.characters?.slice(0, 24) ?? "unnamed"}`,
+    value: parts.join(" / "),
+    cssVariable: `--text-${base}`,
+    source: "figma-api"
+  });
+}
+function extractSpacingTokens(node, tokens, seen) {
+  if (!node.layoutMode || node.layoutMode === "NONE") return;
+  const base = slugify(node.name ?? "frame") || "frame";
+  const paddings = [
+    ["padding-top", node.paddingTop],
+    ["padding-right", node.paddingRight],
+    ["padding-bottom", node.paddingBottom],
+    ["padding-left", node.paddingLeft]
+  ];
+  for (const [prop, value] of paddings) {
+    if (value === void 0 || value === 0) continue;
+    const id = `spacing-${base}-${prop}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    tokens.push({
+      id,
+      category: "spacing",
+      description: `${node.name ?? "Frame"} ${prop}`,
+      value: `${value}px`,
+      cssVariable: `--${base}-${prop}`,
+      source: "figma-api"
+    });
+  }
+  if (node.itemSpacing !== void 0 && node.itemSpacing > 0) {
+    const id = `spacing-${base}-gap`;
+    if (!seen.has(id)) {
+      seen.add(id);
+      tokens.push({
+        id,
+        category: "spacing",
+        description: `${node.name ?? "Frame"} item gap`,
+        value: `${node.itemSpacing}px`,
+        cssVariable: `--${base}-gap`,
+        source: "figma-api"
+      });
+    }
+  }
+}
+function walkNode(node, tokens, seen) {
+  extractColorTokens(node, tokens, seen);
+  extractTypographyTokens(node, tokens, seen);
+  extractSpacingTokens(node, tokens, seen);
+  for (const child of node.children ?? []) {
+    walkNode(child, tokens, seen);
+  }
+}
+async function fetchFigmaDesignTokens(projectRoot, fileKey, nodeId) {
+  const apiKey = readFigmaApiKeyFromMcp(projectRoot);
+  if (!apiKey) return [];
+  const ids = nodeId ? encodeURIComponent(nodeId) : void 0;
+  const url = ids ? `https://api.figma.com/v1/files/${fileKey}/nodes?ids=${ids}` : `https://api.figma.com/v1/files/${fileKey}?depth=2`;
+  const response = await fetch(url, {
+    headers: { "X-Figma-Token": apiKey }
+  });
+  if (!response.ok) return [];
+  const data = await response.json();
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (data.nodes) {
+    for (const entry of Object.values(data.nodes)) {
+      if (entry.document) walkNode(entry.document, tokens, seen);
+    }
+  } else if (data.document) {
+    walkNode(data.document, tokens, seen);
+  }
+  return tokens;
+}
+function isFigmaApiKeyAvailable(projectRoot) {
+  return readFigmaApiKeyFromMcp(projectRoot) !== null;
+}
+
+// src/slash/build.ts
+function hasVisualDesignLinks(projectRoot, lang) {
+  const agentsPath = path15.join(projectRoot, "AGENTS.md");
+  if (!existsSync14(agentsPath)) {
+    return false;
+  }
+  return extractVisualDesignSection(readFileSync12(agentsPath, "utf-8"), lang).length > 0;
+}
+async function promptDesignSupplement(projectRoot, lang) {
+  if (!isStdinTTY()) {
+    console.log(t("build.supplementNonInteractive", lang));
+    return void 0;
+  }
+  console.log("");
+  const { action } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: t("build.supplementQuestion", lang),
+      choices: [
+        { name: t("build.supplementApiKey", lang), value: "api_key" },
+        { name: t("build.supplementDesignLink", lang), value: "design_link" },
+        { name: t("build.supplementSkip", lang), value: "skip" }
+      ]
+    }
+  ]);
+  if (action === "skip") {
+    console.log(chalk3.yellow(t("build.supplementSkipped", lang)));
+    return void 0;
+  }
+  if (action === "api_key") {
+    const { apiKey } = await inquirer3.prompt([
+      {
+        type: "password",
+        name: "apiKey",
+        message: t("init.figmaApiKeyQuestion", lang),
+        mask: "*",
+        validate: (value) => value.trim().length > 0 ? true : t("init.figmaApiKeyRequired", lang)
+      }
+    ]);
+    mergeFigmaMcpConfig(projectRoot, apiKey.trim());
+    console.log(chalk3.green(tf("init.figmaConfigured", lang, { path: ".cursor/mcp.json" })));
+    console.log(chalk3.yellow(t("build.supplementMcpRestartHint", lang)));
+    return { enabled: true, configured: true };
+  }
+  const { link } = await inquirer3.prompt([
+    {
+      type: "input",
+      name: "link",
+      message: t("build.supplementDesignLinkQuestion", lang),
+      validate: (value) => value.trim().length > 0 ? true : t("build.supplementDesignLinkRequired", lang)
+    }
+  ]);
+  console.log(chalk3.cyan(tf("build.supplementLinkNoted", lang, { link: link.trim() })));
+  return void 0;
+}
+async function resolveDesignTokens(projectRoot, designSection, figmaReady) {
+  const links = extractFigmaLinks(designSection);
+  const primary = links.find((l) => l.fileKey) ?? links[0];
+  if (!figmaReady || !primary?.fileKey) {
+    return { tokens: [], primaryLink: primary };
+  }
+  if (!isFigmaApiKeyAvailable(projectRoot)) {
+    return { tokens: [], primaryLink: primary };
+  }
+  try {
+    const tokens = await fetchFigmaDesignTokens(
+      projectRoot,
+      primary.fileKey,
+      primary.nodeId
+    );
+    return { tokens, primaryLink: primary };
+  } catch {
+    return { tokens: [], primaryLink: primary };
+  }
+}
+async function runBuildPrep(config) {
+  const projectRoot = process.cwd();
+  const lang = config.language;
+  const figmaReady = isFigmaMcpConfigured(projectRoot) || config.figma.enabled;
+  const hasDesignLinks = hasVisualDesignLinks(projectRoot, lang);
+  const needsSupplement = !figmaReady || !hasDesignLinks;
+  console.log(`# ${t("build.title", lang)}
+`);
+  console.log(t("build.mandatory", lang));
+  console.log("");
+  console.log(`## ${t("build.stepFetch", lang)}
+`);
+  console.log(t("build.stepFetchDetail", lang));
+  console.log("");
+  const agentsPath = path15.join(projectRoot, "AGENTS.md");
+  let designSection = "";
+  if (existsSync14(agentsPath)) {
+    designSection = extractVisualDesignSection(readFileSync12(agentsPath, "utf-8"), lang);
+    if (designSection) {
+      console.log(`### ${t("build.designLinksFromAgents", lang)}
+`);
+      console.log(designSection);
+      console.log("");
+    }
+  }
+  console.log(`## ${t("build.figmaMcpStatus", lang)}
+`);
+  if (figmaReady) {
+    console.log(t("build.figmaMcpReady", lang));
+  } else {
+    console.log(t("build.figmaMcpMissing", lang));
+  }
+  console.log("");
+  console.log(`## ${t("build.fidelityRules", lang)}
+`);
+  console.log(t("build.fidelityRulesDetail", lang));
+  console.log("");
+  console.log(`## ${t("build.visualSpec", lang)}
+`);
+  console.log(t("build.visualSpecDetail", lang));
+  console.log("");
+  const skillPath = getVisualFidelitySkillPath(projectRoot);
+  const { tokens, primaryLink } = await resolveDesignTokens(
+    projectRoot,
+    designSection,
+    figmaReady
+  );
+  const specResult = ensureVisualSpec(projectRoot, lang, designSection, tokens, primaryLink);
+  const checklist = readVisualChecklist(projectRoot);
+  const counts = countChecklistByStatus(checklist);
+  console.log(tf("build.visualSpecWritten", lang, { path: specResult.specPath }));
+  console.log(tf("build.visualChecklistWritten", lang, { path: specResult.checklistPath }));
+  if (tokens.length > 0) {
+    console.log(tf("build.figmaTokensExtracted", lang, { count: String(tokens.length) }));
+  } else if (figmaReady && primaryLink?.fileKey) {
+    console.log(t("build.figmaTokensEmpty", lang));
+  }
+  console.log(tf("build.visualSkillPath", lang, { path: skillPath }));
+  console.log(tf("build.checklistSummary", lang, {
+    passed: String(counts.passed),
+    pending: String(counts.pending),
+    total: String(counts.total)
+  }));
+  console.log("");
+  let figmaUpdate;
+  if (needsSupplement) {
+    console.log(`## ${t("build.supplement", lang)}
+`);
+    console.log(t("build.supplementDetail", lang));
+    console.log("");
+    figmaUpdate = await promptDesignSupplement(projectRoot, lang);
+  }
+  console.log(`## ${t("build.nextStep", lang)}
+`);
+  console.log(t("build.nextStepDetail", lang));
+  console.log("");
+  console.log(t("build.agentMustReadSkill", lang));
+  return figmaUpdate ? { figma: figmaUpdate } : {};
+}
+
+// src/slash/visual-regression-prep.ts
+import path16 from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+async function runVisualRegressionPrep(config, mode) {
+  const projectRoot = process.cwd();
+  const lang = config.language;
+  const prefix = mode;
+  console.log(`# ${t(`${prefix}.title`, lang)}
+`);
+  console.log(t(`${prefix}.regressionIntro`, lang));
+  console.log("");
+  const specPath = getVisualSpecPath(projectRoot);
+  const checklistPath = getVisualChecklistPath(projectRoot);
+  const skillPath = getVisualFidelitySkillPath(projectRoot);
+  if (existsSync15(specPath)) {
+    console.log(tf("regression.specPath", lang, { path: specPath }));
+  } else {
+    console.log(t("regression.specMissing", lang));
+  }
+  if (existsSync15(checklistPath)) {
+    const checklist = readVisualChecklist(projectRoot);
+    const counts = countChecklistByStatus(checklist);
+    console.log(tf("regression.checklistSummary", lang, {
+      passed: String(counts.passed),
+      pending: String(counts.pending),
+      failed: String(counts.failed),
+      total: String(counts.total)
+    }));
+    const locked = checklist.items.filter((i) => i.status === "passed");
+    if (locked.length > 0) {
+      console.log("");
+      console.log(`### ${t("regression.lockedItems", lang)}
+`);
+      for (const item of locked) {
+        console.log(`- \`${item.id}\`: ${item.description} (${item.designValue})`);
+      }
+    }
+  } else {
+    console.log(t("regression.checklistMissing", lang));
+  }
+  console.log("");
+  console.log(tf("regression.skillPath", lang, { path: skillPath }));
+  console.log("");
+  console.log(`## ${t("regression.protocol", lang)}
+`);
+  console.log(t("regression.protocolDetail", lang));
+  console.log("");
+  const agentsPath = path16.join(projectRoot, "AGENTS.md");
+  if (existsSync15(agentsPath)) {
+    const designSection = extractVisualDesignSection(readFileSync13(agentsPath, "utf-8"), lang);
+    if (designSection) {
+      console.log(`### ${t("regression.designContext", lang)}
+`);
+      console.log(designSection);
+      console.log("");
+    }
+  }
+  console.log(t(`${prefix}.agentMustReadSkill`, lang));
+}
+
+// src/slash/tweak.ts
+async function runTweakPrep(config) {
+  await runVisualRegressionPrep(config, "tweak");
+}
+
+// src/slash/hotfix.ts
+async function runHotfixPrep(config) {
+  await runVisualRegressionPrep(config, "hotfix");
+}
+
+// src/slash/verify.ts
+import chalk4 from "chalk";
+import { existsSync as existsSync16 } from "fs";
+import path17 from "path";
+async function runVerifyPrep(config) {
+  const projectRoot = process.cwd();
+  const lang = config.language;
+  console.log(`# ${t("verify.title", lang)}
+`);
+  console.log(t("verify.intro", lang));
+  console.log("");
+  const checklistPath = getVisualChecklistPath(projectRoot);
+  if (existsSync16(checklistPath)) {
+    const checklist = readVisualChecklist(projectRoot);
+    const counts = countChecklistByStatus(checklist);
+    console.log(`## ${t("verify.checklistGate", lang)}
+`);
+    console.log(tf("verify.checklistSummary", lang, {
+      passed: String(counts.passed),
+      pending: String(counts.pending),
+      failed: String(counts.failed),
+      total: String(counts.total)
+    }));
+    if (counts.failed > 0) {
+      console.log(chalk4.yellow(t("verify.checklistFailed", lang)));
+    }
+    if (counts.pending > 0) {
+      console.log(chalk4.yellow(t("verify.checklistPending", lang)));
+    }
+    console.log("");
+  } else {
+    console.log(chalk4.yellow(t("verify.checklistMissing", lang)));
+    console.log("");
+  }
+  const configPath = ensureVisualVerifyConfig(projectRoot);
+  const verifyConfig = readVisualVerifyConfig(projectRoot);
+  console.log(`## ${t("verify.visualDiff", lang)}
+`);
+  console.log(tf("verify.configPath", lang, { path: configPath }));
+  if (!verifyConfig?.enabled) {
+    console.log(t("verify.visualDiffDisabled", lang));
+    console.log(t("verify.enableHint", lang));
+    console.log(tf("verify.scriptPath", lang, { path: path17.join(getScriptsDir(), "visual-diff.mjs") }));
+    console.log("");
+    console.log(t("verify.nextStepDetail", lang));
+    return { visualDiffFailed: false };
+  }
+  if (!hasVisualDiffDependencies(projectRoot)) {
+    console.log(chalk4.yellow(t("verify.depsMissing", lang)));
+    console.log(t("verify.depsInstall", lang));
+    console.log(tf("verify.scriptPath", lang, { path: path17.join(getScriptsDir(), "visual-diff.mjs") }));
+    console.log("");
+    console.log(t("verify.nextStepDetail", lang));
+    return { visualDiffFailed: false };
+  }
+  console.log(t("verify.screensConfigured", lang));
+  console.log(formatVerifyConfigSummary(verifyConfig, lang));
+  console.log("");
+  console.log(t("verify.runningDiff", lang));
+  const { exitCode, report, stdout } = await runVisualDiff(projectRoot);
+  if (stdout) {
+    console.log(stdout.split("\n").filter((line) => !line.startsWith("{")).join("\n"));
+  }
+  if (report) {
+    console.log("");
+    if (report.passed) {
+      console.log(chalk4.green(t("verify.visualDiffPassed", lang)));
+    } else {
+      console.log(chalk4.red(t("verify.visualDiffFailed", lang)));
+      for (const result of report.results.filter((r) => !r.passed)) {
+        console.log(chalk4.red(`  \u2717 ${result.id}: ${result.error ?? `${result.diffPercent}% diff`}`));
+        if (result.diff) {
+          console.log(chalk4.gray(`    diff: ${result.diff}`));
+        }
+      }
+    }
+  }
+  console.log("");
+  console.log(t("verify.nextStepDetail", lang));
+  console.log(t("verify.agentInstruction", lang));
+  return { visualDiffFailed: exitCode !== 0 && verifyConfig.enabled };
+}
+
 // src/core/rtk-bridge.ts
-import { execa as execa4 } from "execa";
+import { execa as execa5 } from "execa";
 
 // src/core/rtk.ts
 var HEAD_LINES = 200;
@@ -724,7 +1469,7 @@ async function runWithRtk(command, args, config, options = {}) {
   const ttyPassthrough = options.inheritStdio ?? false;
   const rtkOff = options.rtkDisabled || bypass || ttyPassthrough;
   if (ttyPassthrough) {
-    const subprocess = execa4(command, args, {
+    const subprocess = execa5(command, args, {
       cwd: options.cwd,
       stdio: "inherit",
       reject: false
@@ -736,7 +1481,7 @@ async function runWithRtk(command, args, config, options = {}) {
       exitCode: result2.exitCode ?? (result2.failed ? 1 : 0)
     };
   }
-  const result = await execa4(command, args, {
+  const result = await execa5(command, args, {
     cwd: options.cwd,
     reject: false,
     all: true
@@ -759,7 +1504,7 @@ ${result.stderr}`;
 }
 async function runCometPassthrough(subcommand, extraArgs, config, options = {}) {
   const args = [subcommand, ...extraArgs];
-  const isTTY = isStdoutTTY() && isStdinTTY();
+  const isTTY = isStdoutTTY() && isStdinTTY2();
   if (isTTY) {
     const result = await runWithRtk("comet", args, config, {
       ...options,
@@ -784,12 +1529,12 @@ async function runCometPassthrough(subcommand, extraArgs, config, options = {})
     throw err;
   }
 }
-function isStdinTTY() {
+function isStdinTTY2() {
   return Boolean(process.stdin.isTTY);
 }
 
 // src/slash/comet-passthrough.ts
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 var COMET_MAP = {
   open: "open",
   design: "design",
@@ -807,74 +1552,124 @@ async function runCometSlash(subcommand, args, config) {
   } catch (err) {
     const message = err.message;
     if (message === "NON_INTERACTIVE_FAILED") {
-      console.error(chalk3.red(t("error.cometNonInteractive", config.language)));
-      console.error(chalk3.yellow(t("error.cometUseTerminal", config.language)));
+      console.error(chalk5.red(t("error.cometNonInteractive", config.language)));
+      console.error(chalk5.yellow(t("error.cometUseTerminal", config.language)));
       return 1;
     }
-    console.error(chalk3.red(String(err)));
+    console.error(chalk5.red(String(err)));
     return 1;
   }
 }
 
-// src/slash/graph-setup.ts
-import chalk4 from "chalk";
-async function runGraphSetup(config) {
-  const lang = config.language;
-  const installed = await detectGitNexus();
-  if (!installed) {
-    console.log(chalk4.yellow(t("graph.setupGuide", lang)));
-    console.log(chalk4.cyan("npm install -g gitnexus"));
-  } else {
-    console.log(chalk4.green(t("graph.alreadyInstalled", lang)));
-  }
-  const adapterList = getAdaptersForPlatforms(config.tools);
-  await configureMcpForAdapters(adapterList, lang);
+// src/slash/sync-cursor-commands.ts
+import chalk6 from "chalk";
+async function runSyncCursorCommands() {
+  const config = await loadConfig();
+  const count = injectCursorSlashCommands();
+  console.log(
+    chalk6.green(tf("cursor.commandsSynced", config.language, { count: String(count) }))
+  );
+  const skillCount = injectVisualFidelitySkill();
+  console.log(
+    chalk6.green(tf("cursor.skillsSynced", config.language, { count: String(skillCount) }))
+  );
+  console.log(chalk6.cyan(t("cursor.commandsHint", config.language)));
 }
 
-// src/slash/graph-init.ts
-async function runGraphInit(config) {
-  const result = await runWithRtk("gitnexus", ["analyze"], config);
-  process.exit(result.exitCode);
-}
+// src/slash/visual-tools-install.ts
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
+import chalk7 from "chalk";
+import { execa as execa6 } from "execa";
 
-// src/slash/graph-refresh.ts
-async function runGraphRefresh(config) {
-  const result = await runWithRtk("gitnexus", ["analyze", "--force"], config);
-  process.exit(result.exitCode);
+// src/core/visual-tools.ts
+var VISUAL_DIFF_PACKAGES = ["playwright", "pixelmatch", "pngjs"];
+function getMissingVisualDiffDeps(projectRoot) {
+  return VISUAL_DIFF_PACKAGES.filter((pkg) => !resolveProjectDependency(projectRoot, pkg));
+}
+function buildInstallDevDepsCommand(packageManager) {
+  const packages = [...VISUAL_DIFF_PACKAGES];
+  switch (packageManager) {
+    case "pnpm":
+      return { command: "pnpm", args: ["add", "-D", ...packages] };
+    case "yarn":
+      return { command: "yarn", args: ["add", "-D", ...packages] };
+    case "bun":
+      return { command: "bun", args: ["add", "-d", ...packages] };
+    default:
+      return { command: "npm", args: ["install", "-D", ...packages] };
+  }
+}
+function buildPlaywrightInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "pnpm":
+      return { command: "pnpm", args: ["exec", "playwright", "install", "chromium"] };
+    case "yarn":
+      return { command: "yarn", args: ["exec", "playwright", "install", "chromium"] };
+    case "bun":
+      return { command: "bunx", args: ["playwright", "install", "chromium"] };
+    default:
+      return { command: "npx", args: ["playwright", "install", "chromium"] };
+  }
 }
 
-// src/slash/graph-handoff.ts
-import chalk5 from "chalk";
-async function runGraphHandoff(config) {
-  const lang = config.language;
-  console.log(chalk5.bold(`## A. ${t("graph.handoffSummary", lang)}
-`));
-  const summary = await runWithRtk("gitnexus", ["query", "--summary"], config);
-  if (summary.exitCode !== 0) {
-    console.log(chalk5.yellow(t("graph.summaryFailed", lang)));
-  }
-  console.log(chalk5.bold(`
-## B. ${t("graph.handoffPrompt", lang)}
-`));
-  console.log(t("graph.handoffPromptBody", lang));
-  console.log(chalk5.bold(`
-## C. ${t("graph.handoffTimestamp", lang)}
-`));
-  updateGraphTimestampInAgents();
-  console.log(chalk5.green(t("graph.timestampUpdated", lang)));
-}
-
-// src/slash/graph-status.ts
-import chalk6 from "chalk";
-async function runGraphStatus(config) {
+// src/slash/visual-tools-install.ts
+async function runVisualToolsInstall(config) {
+  const projectRoot = process.cwd();
   const lang = config.language;
-  const version = await detectGitNexus();
-  const graphExists = gitNexusGraphExists();
-  const indexCount = countGitNexusIndexFiles();
-  console.log(chalk6.bold(t("graph.statusTitle", lang)));
-  console.log(`${t("graph.statusInstalled", lang)}: ${version ? chalk6.green(version) : chalk6.red("no")}`);
-  console.log(`${t("graph.statusGraph", lang)}: ${graphExists ? chalk6.green("yes") : chalk6.yellow("no")}`);
-  console.log(`${t("graph.statusIndexFiles", lang)}: ${indexCount}`);
+  console.log(`# ${t("visualTools.title", lang)}
+`);
+  console.log(t("visualTools.intro", lang));
+  console.log("");
+  const packageJsonPath = path18.join(projectRoot, "package.json");
+  if (!existsSync17(packageJsonPath)) {
+    console.error(chalk7.red(t("visualTools.noPackageJson", lang)));
+    return 1;
+  }
+  const pm = detectPackageManager(projectRoot);
+  console.log(tf("visualTools.packageManager", lang, { pm }));
+  console.log("");
+  const missing = getMissingVisualDiffDeps(projectRoot);
+  if (missing.length === 0) {
+    console.log(chalk7.green(t("visualTools.depsAlreadyInstalled", lang)));
+  } else {
+    const install = buildInstallDevDepsCommand(pm);
+    console.log(tf("visualTools.installingDeps", lang, { packages: missing.join(", ") }));
+    console.log(chalk7.gray(`$ ${[install.command, ...install.args].join(" ")}`));
+    console.log("");
+    const depsResult = await execa6(install.command, install.args, {
+      cwd: projectRoot,
+      stdio: "inherit",
+      reject: false
+    });
+    if (depsResult.exitCode !== 0) {
+      console.error(chalk7.red(t("visualTools.depsInstallFailed", lang)));
+      return depsResult.exitCode ?? 1;
+    }
+    console.log(chalk7.green(t("visualTools.depsInstalled", lang)));
+    console.log("");
+  }
+  const browserInstall = buildPlaywrightInstallCommand(pm);
+  console.log(t("visualTools.installingBrowsers", lang));
+  console.log(chalk7.gray(`$ ${[browserInstall.command, ...browserInstall.args].join(" ")}`));
+  console.log("");
+  const browserResult = await execa6(browserInstall.command, browserInstall.args, {
+    cwd: projectRoot,
+    stdio: "inherit",
+    reject: false
+  });
+  if (browserResult.exitCode !== 0) {
+    console.error(chalk7.red(t("visualTools.browsersInstallFailed", lang)));
+    return browserResult.exitCode ?? 1;
+  }
+  if (!hasVisualDiffDependencies(projectRoot)) {
+    console.error(chalk7.red(t("visualTools.verifyFailed", lang)));
+    return 1;
+  }
+  console.log(chalk7.green.bold(t("visualTools.success", lang)));
+  console.log("");
+  console.log(t("visualTools.nextStep", lang));
+  return 0;
 }
 
 // src/cli/commands/slash.ts
@@ -887,27 +1682,21 @@ var COMET_COMMANDS = [
   "hotfix",
   "tweak"
 ];
-var GRAPH_COMMANDS = [
-  "graph-setup",
-  "graph-init",
-  "graph-refresh",
-  "graph-handoff",
-  "graph-status"
-];
 var ALL_COMMANDS = [
   "fill-context",
   ...COMET_COMMANDS,
-  ...GRAPH_COMMANDS
+  "sync-cursor-commands",
+  "visual-tools-install"
 ];
 function gateCometCommands(projectRoot, lang) {
   if (agentsMdHasPendingPlaceholders(projectRoot)) {
-    console.error(chalk7.yellow(t("gate.fillContextFirst", lang)));
+    console.error(chalk8.yellow(t("gate.fillContextFirst", lang)));
     process.exit(1);
   }
 }
 async function runSlash(command, args) {
   if (!ALL_COMMANDS.includes(command)) {
-    console.error(chalk7.red(`Unknown slash command: ${command}`));
+    console.error(chalk8.red(`Unknown slash command: ${command}`));
     process.exit(1);
   }
   const projectRoot = process.cwd();
@@ -916,28 +1705,44 @@ async function runSlash(command, args) {
   const slashCmd = command;
   if (COMET_COMMANDS.includes(slashCmd)) {
     gateCometCommands(projectRoot, lang);
+    if (slashCmd === "build") {
+      const prepResult = await runBuildPrep(config);
+      if (prepResult.figma) {
+        writeDefaultConfig(projectRoot, mergeConfig({ ...config, figma: prepResult.figma }));
+      }
+      console.log("");
+    }
+    if (slashCmd === "tweak") {
+      await runTweakPrep(config);
+      console.log("");
+    }
+    if (slashCmd === "hotfix") {
+      await runHotfixPrep(config);
+      console.log("");
+    }
+    let visualDiffFailed = false;
+    if (slashCmd === "verify") {
+      const verifyResult = await runVerifyPrep(config);
+      visualDiffFailed = verifyResult.visualDiffFailed;
+      console.log("");
+    }
     const exitCode = await runCometSlash(slashCmd, args, config);
+    if (visualDiffFailed && exitCode === 0) {
+      process.exit(1);
+    }
     process.exit(exitCode);
   }
   switch (slashCmd) {
     case "fill-context":
       await runFillContext(config);
       break;
-    case "graph-setup":
-      await runGraphSetup(config);
-      break;
-    case "graph-init":
-      await runGraphInit(config);
-      break;
-    case "graph-refresh":
-      await runGraphRefresh(config);
-      break;
-    case "graph-handoff":
-      await runGraphHandoff(config);
-      break;
-    case "graph-status":
-      await runGraphStatus(config);
+    case "sync-cursor-commands":
+      await runSyncCursorCommands();
       break;
+    case "visual-tools-install": {
+      const exitCode = await runVisualToolsInstall(config);
+      process.exit(exitCode);
+    }
     default:
       process.exit(1);
   }
@@ -945,14 +1750,14 @@ async function runSlash(command, args) {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("ft").description("Frontend Toolkit \u2014 orchestration layer for Comet and GitNexus").version("0.1.0");
+program.name("ft").description("Frontend Toolkit \u2014 orchestration layer for Comet and Karpathy rules").version("0.1.0");
 program.command("init").description("Full project initialization pipeline").option("--lang <lang>", "Language: zh-CN or en").action(async (options) => {
   await runInit({ lang: options.lang });
 });
 program.command("update").description("Update @nick848/ft globally").action(async () => {
   await runUpdate();
 });
-program.command("version").description("Show FT, Comet, and GitNexus versions").action(async () => {
+program.command("version").description("Show FT and Comet versions").action(async () => {
   await runVersion();
 });
 program.command("help").description("Show help").action(() => {