@nick848/fet 1.1.5 → 1.1.7

package/dist/cli/index.js

@@ -188,18 +188,18 @@ function toGitNexusState(detection, previous) {
   };
 }
 async function inspectGitNexusGraph(projectRoot, env = process.env) {
-  const relative2 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
-  const graphPath = join5(projectRoot, relative2);
+  const relative4 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
+  const graphPath = join5(projectRoot, relative4);
   try {
     const info = await stat2(graphPath);
     return {
-      graphPath: relative2,
+      graphPath: relative4,
       graphExists: true,
       lastIndexedAt: info.mtime.toISOString()
     };
   } catch {
     return {
-      graphPath: relative2,
+      graphPath: relative4,
       graphExists: false,
       lastIndexedAt: null
     };
@@ -366,12 +366,670 @@ async function exists(path) {
 
 // src/commands/fill-context.ts
 import { mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
+
+// src/agents-miniprogram.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join9 } from "path";
+
+// src/scanner/miniprogram.ts
+import { readdir, readFile as readFile6, stat as stat5 } from "fs/promises";
+import { join as join8, relative } from "path";
+
+// src/scanner/package.ts
+import { readFile as readFile5, stat as stat4 } from "fs/promises";
+import { join as join7 } from "path";
+import { parse } from "yaml";
+async function readPackageJson(projectRoot) {
+  try {
+    return JSON.parse(await readFile5(join7(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function detectPackageManager(projectRoot, pkg) {
+  const warnings = [];
+  if (pkg?.packageManager) {
+    const declared = pkg.packageManager.split("@")[0] ?? "unknown";
+    const locks2 = await detectLockManagers(projectRoot);
+    const conflicting = locks2.filter((item) => item !== declared);
+    if (conflicting.length) {
+      warnings.push(`packageManager \u58F0\u660E\u4E3A ${declared}\uFF0C\u4F46\u540C\u65F6\u53D1\u73B0\u9501\u6587\u4EF6\uFF1A${conflicting.join(", ")}`);
+    }
+    return { manager: declared, confidence: "high", warnings };
+  }
+  const locks = await detectLockManagers(projectRoot);
+  if (locks.length > 1) {
+    warnings.push(`\u53D1\u73B0\u591A\u4E2A\u5305\u7BA1\u7406\u5668\u9501\u6587\u4EF6\uFF1A${locks.join(", ")}\uFF0C\u9ED8\u8BA4\u4F7F\u7528 ${locks[0]}`);
+    return { manager: locks[0] ?? "npm", confidence: "medium", warnings };
+  }
+  if (locks[0]) {
+    return { manager: locks[0], confidence: "high", warnings };
+  }
+  return { manager: "npm", confidence: "low", warnings };
+}
+function extractCommands(pkg, packageManager) {
+  const scripts = pkg?.scripts ?? {};
+  const result = {};
+  const scriptNames = ["dev", "build", "lint", "typecheck", "check", "test", "test:unit"];
+  for (const name of scriptNames) {
+    if (scripts[name]) {
+      const dimension = name === "check" ? "typecheck" : name === "test:unit" ? "test" : name;
+      if (result[dimension]) {
+        continue;
+      }
+      result[dimension] = {
+        command: scriptCommand(packageManager, name),
+        source: `package.json:scripts.${name}`,
+        required: name === "build"
+      };
+    }
+  }
+  return result;
+}
+function detectFramework(pkg) {
+  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  const candidates = [
+    ["next", ["next"]],
+    ["nuxt", ["nuxt"]],
+    ["vite", ["vite"]],
+    ["sveltekit", ["@sveltejs/kit"]],
+    ["angular", ["@angular/core", "@angular/cli"]],
+    ["react", ["react"]],
+    ["vue", ["vue"]],
+    ["svelte", ["svelte"]]
+  ];
+  for (const [candidate, packages] of candidates) {
+    if (packages.some((name) => deps[name])) {
+      return { name: candidate, confidence: "high", sources: ["package.json"] };
+    }
+  }
+  return { name: "unknown", confidence: "low", sources: [] };
+}
+async function detectLanguage(projectRoot, pkg) {
+  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  if (deps.typescript || await exists2(join7(projectRoot, "tsconfig.json"))) {
+    return "typescript";
+  }
+  return "javascript";
+}
+async function detectWorkspaces(projectRoot, pkg) {
+  const packageWorkspaces = normalizeWorkspaces(pkg?.workspaces).map((path) => ({
+    name: path,
+    path,
+    source: "package.json:workspaces"
+  }));
+  if (packageWorkspaces.length) {
+    return packageWorkspaces;
+  }
+  try {
+    const workspace = parse(await readFile5(join7(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    return (workspace?.packages ?? []).map((path) => ({
+      name: path,
+      path,
+      source: "pnpm-workspace.yaml:packages"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function detectLockManagers(projectRoot) {
+  const lockFiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  const found = [];
+  for (const [file, manager] of lockFiles) {
+    if (await exists2(join7(projectRoot, file))) {
+      found.push(manager);
+    }
+  }
+  return found;
+}
+function normalizeWorkspaces(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces;
+  }
+  return workspaces?.packages ?? [];
+}
+function scriptCommand(packageManager, name) {
+  return packageManager === "npm" ? `npm run ${name}` : `${packageManager} ${name}`;
+}
+async function exists2(path) {
+  try {
+    await stat4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/miniprogram.ts
+var MAIN_PACKAGE_LIMIT_BYTES = 2 * 1024 * 1024;
+var SUBPACKAGE_LIMIT_BYTES = 2 * 1024 * 1024;
+var TOTAL_LIMIT_BYTES = 20 * 1024 * 1024;
+var NEAR_LIMIT_BYTES = Math.floor(1.7 * 1024 * 1024);
+async function detectMiniprogramProject(projectRoot) {
+  const pkg = await readPackageJson(projectRoot);
+  const platform = await resolvePlatform(projectRoot, pkg);
+  if (!platform) {
+    return { supported: false };
+  }
+  const appJsonPath = await resolveAppJsonPath(projectRoot, platform);
+  if (!appJsonPath) {
+    return { supported: false };
+  }
+  const miniprogramRoot = dirnameNormalized(appJsonPath);
+  const appJson = await readAppJson(appJsonPath);
+  if (!appJson) {
+    return { supported: false };
+  }
+  const subPackages = appJson.subPackages ?? appJson.subpackages ?? [];
+  const subRoots = subPackages.map((item) => normalizeRelative(item.root ?? "")).filter(Boolean);
+  const mainPagePaths = appJson.pages ?? [];
+  const mainDirs = uniquePaths(mainPagePaths.map((page) => pageDir(page)).filter(Boolean));
+  const mainSize = await sumPaths(miniprogramRoot, mainDirs, subRoots);
+  const mainPackage = {
+    name: "main",
+    root: miniprogramRoot,
+    sizeBytes: mainSize,
+    sizeLabel: formatBytes(mainSize),
+    limitBytes: MAIN_PACKAGE_LIMIT_BYTES,
+    status: sizeStatus(mainSize, MAIN_PACKAGE_LIMIT_BYTES),
+    pagePaths: mainPagePaths
+  };
+  const subpackageReports = [];
+  for (const sub of subPackages) {
+    const root = normalizeRelative(sub.root ?? "");
+    if (!root) {
+      continue;
+    }
+    const size = await directorySize(join8(miniprogramRoot, root));
+    subpackageReports.push({
+      name: sub.name ?? root.replace(/\/$/, ""),
+      root,
+      sizeBytes: size,
+      sizeLabel: formatBytes(size),
+      limitBytes: SUBPACKAGE_LIMIT_BYTES,
+      status: sizeStatus(size, SUBPACKAGE_LIMIT_BYTES),
+      pagePaths: sub.pages ?? []
+    });
+  }
+  const totalSizeBytes = mainPackage.sizeBytes + subpackageReports.reduce((sum, item) => sum + item.sizeBytes, 0);
+  const warnings = [];
+  if (totalSizeBytes >= NEAR_LIMIT_BYTES) {
+    warnings.push(
+      totalSizeBytes >= TOTAL_LIMIT_BYTES ? "\u6E90\u7801\u76EE\u5F55\u5408\u8BA1\u4F53\u79EF\u5DF2\u8FBE\u5230\u6216\u8D85\u8FC7 20MB \u53C2\u8003\u4E0A\u9650\uFF0C\u9700\u6574\u4F53\u7626\u8EAB\u3002" : "\u6E90\u7801\u76EE\u5F55\u5408\u8BA1\u4F53\u79EF\u5DF2\u63A5\u8FD1 20MB \u53C2\u8003\u4E0A\u9650\u3002"
+    );
+  }
+  return {
+    supported: true,
+    platform: platform.id,
+    platformLabel: platform.label,
+    projectType: platform.projectType,
+    appJsonPath: relative(projectRoot, appJsonPath).replace(/\\/g, "/"),
+    miniprogramRoot: relative(projectRoot, miniprogramRoot).replace(/\\/g, "/") || ".",
+    mainPackage,
+    subpackages: subpackageReports,
+    totalSizeBytes,
+    warnings
+  };
+}
+async function resolvePlatform(projectRoot, pkg) {
+  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  if (await exists3(join8(projectRoot, "project.config.json"))) {
+    return { id: "wechat", label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F", projectType: "\u5FAE\u4FE1\u539F\u751F / \u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177" };
+  }
+  if (deps["@tarojs/taro"] || deps["@tarojs/cli"] || await exists3(join8(projectRoot, "config", "index.ts"))) {
+    return { id: "taro", label: "Taro\uFF08\u53EF\u53D1\u5E03\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\uFF09", projectType: "Taro \u8DE8\u7AEF\u5C0F\u7A0B\u5E8F" };
+  }
+  if (await exists3(join8(projectRoot, "manifest.json")) && await exists3(join8(projectRoot, "pages.json"))) {
+    return { id: "uni-app", label: "uni-app\uFF08\u53EF\u53D1\u5E03\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\uFF09", projectType: "uni-app \u8DE8\u7AEF\u5C0F\u7A0B\u5E8F" };
+  }
+  if (await exists3(join8(projectRoot, "app.json"))) {
+    return { id: "wechat", label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F", projectType: "\u5FAE\u4FE1\u539F\u751F\uFF08app.json\uFF09" };
+  }
+  if (await exists3(join8(projectRoot, "miniprogram", "app.json"))) {
+    return { id: "wechat", label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F", projectType: "\u5FAE\u4FE1\u539F\u751F\uFF08miniprogram \u76EE\u5F55\uFF09" };
+  }
+  if (deps["miniprogram-api-typings"]) {
+    return { id: "wechat", label: "\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F", projectType: "\u5FAE\u4FE1 API \u7C7B\u578B\u5B9A\u4E49\u9879\u76EE" };
+  }
+  return null;
+}
+async function resolveAppJsonPath(projectRoot, platform) {
+  const candidates = [];
+  if (platform.id === "wechat") {
+    try {
+      const config = JSON.parse(await readFile6(join8(projectRoot, "project.config.json"), "utf8"));
+      if (config.miniprogramRoot) {
+        candidates.push(join8(projectRoot, config.miniprogramRoot, "app.json"));
+      }
+    } catch {
+    }
+    candidates.push(join8(projectRoot, "app.json"), join8(projectRoot, "miniprogram", "app.json"));
+  } else {
+    candidates.push(
+      join8(projectRoot, "src", "app.json"),
+      join8(projectRoot, "app.json"),
+      join8(projectRoot, "miniprogram", "app.json"),
+      join8(projectRoot, "dist", "app.json")
+    );
+  }
+  for (const candidate of candidates) {
+    if (await exists3(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function readAppJson(path) {
+  try {
+    return JSON.parse(await readFile6(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function sumPaths(baseDir, dirs, excludedRoots) {
+  let total = 0;
+  const visited = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const abs = join8(baseDir, dir);
+    if (visited.has(abs)) {
+      continue;
+    }
+    visited.add(abs);
+    total += await directorySize(abs);
+  }
+  const rootFiles = await readdir(baseDir, { withFileTypes: true });
+  for (const entry of rootFiles) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (shouldSkipName(entry.name)) {
+      continue;
+    }
+    total += (await stat5(join8(baseDir, entry.name))).size;
+  }
+  for (const entry of rootFiles) {
+    if (!entry.isDirectory() || shouldSkipName(entry.name)) {
+      continue;
+    }
+    const rel = `${entry.name}/`;
+    if (dirs.some((dir) => dir === entry.name || dir.startsWith(`${entry.name}/`))) {
+      continue;
+    }
+    if (excludedRoots.some((root) => root === entry.name || root.startsWith(`${entry.name}/`) || rel.startsWith(root))) {
+      continue;
+    }
+    total += await directorySize(join8(baseDir, entry.name));
+  }
+  return total;
+}
+async function directorySize(targetPath) {
+  try {
+    const info = await stat5(targetPath);
+    if (!info.isDirectory()) {
+      return info.size;
+    }
+  } catch {
+    return 0;
+  }
+  let total = 0;
+  const queue = [targetPath];
+  while (queue.length) {
+    const current = queue.pop();
+    if (!current) {
+      break;
+    }
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (shouldSkipName(entry.name)) {
+        continue;
+      }
+      const next = join8(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(next);
+      } else if (entry.isFile()) {
+        try {
+          total += (await stat5(next)).size;
+        } catch {
+        }
+      }
+    }
+  }
+  return total;
+}
+function pageDir(pagePath) {
+  const normalized = pagePath.replace(/^\//, "");
+  const parts = normalized.split("/");
+  if (parts.length <= 1) {
+    return parts[0] ?? "";
+  }
+  return parts.slice(0, -1).join("/");
+}
+function sizeStatus(sizeBytes, limitBytes) {
+  if (sizeBytes >= limitBytes) {
+    return "over_limit";
+  }
+  if (sizeBytes >= NEAR_LIMIT_BYTES) {
+    return "near_limit";
+  }
+  return "ok";
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+function normalizeRelative(value) {
+  return value.replace(/^\//, "").replace(/\\/g, "/");
+}
+function uniquePaths(paths) {
+  return [...new Set(paths.filter(Boolean))];
+}
+function shouldSkipName(name) {
+  return name === "node_modules" || name === ".git" || name === "miniprogram_npm" || name.startsWith(".");
+}
+function dirnameNormalized(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  parts.pop();
+  return parts.join("/") || ".";
+}
+async function exists3(path) {
+  try {
+    await stat5(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/templates/miniprogram-agents.ts
+var MAIN_LIMIT_MB = 2;
+var SUB_LIMIT_MB = 2;
+var TOTAL_LIMIT_MB = 20;
+var NEAR_LIMIT_MB = 1.7;
+function renderMiniprogramPlaceholderSection(language) {
+  if (language === "en") {
+    return `## Mini Program
+
+- Platform: [NEEDS LLM INPUT]
+- Project type: [NEEDS LLM INPUT]
+
+### Package size (filled by \`fet fill-context\`)
+
+[NEEDS LLM INPUT]
+
+### Development constraints
+
+[NEEDS LLM INPUT]`;
+  }
+  return `## \u5C0F\u7A0B\u5E8F
+
+- \u5E73\u53F0\uFF1A[NEEDS LLM INPUT]
+- \u5DE5\u7A0B\u7C7B\u578B\uFF1A[NEEDS LLM INPUT]
+
+### \u5305\u4F53\u79EF\uFF08\u7531 \`fet fill-context\` \u626B\u63CF\u8865\u5145\uFF09
+
+[NEEDS LLM INPUT]
+
+### \u5F00\u53D1\u7EA6\u675F
+
+[NEEDS LLM INPUT]`;
+}
+function renderMiniprogramFilledSection(scan, language) {
+  if (language === "en") {
+    return renderMiniprogramFilledSectionEn(scan);
+  }
+  return renderMiniprogramFilledSectionZh(scan);
+}
+function renderMiniprogramFilledSectionZh(scan) {
+  const sizeTable = renderSizeTableZh(scan);
+  const rules = renderConstraintRulesZh(scan);
+  const warnings = scan.warnings.length ? `
+
+\u626B\u63CF\u63D0\u793A\uFF1A${scan.warnings.join("\uFF1B")}` : "";
+  return `## \u5C0F\u7A0B\u5E8F
+
+- \u5E73\u53F0\uFF1A${scan.platformLabel}
+- \u5DE5\u7A0B\u7C7B\u578B\uFF1A${scan.projectType}
+- \u914D\u7F6E\uFF1A\`${scan.appJsonPath}\`\uFF08\u6839\u76EE\u5F55 \`${scan.miniprogramRoot}/\`\uFF09
+
+### \u5305\u4F53\u79EF\uFF08\u6E90\u7801\u76EE\u5F55\u4F30\u7B97\uFF0C\u4E0A\u4F20\u524D\u4EE5\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177 / CI \u6784\u5EFA\u4EA7\u7269\u4E3A\u51C6\uFF09
+
+${sizeTable}
+
+> \u8BF4\u660E\uFF1A\u4E0B\u8868\u6309\u4ED3\u5E93\u5185\u9875\u9762/\u5206\u5305\u76EE\u5F55\u6E90\u7801\u4F53\u79EF\u7D2F\u8BA1\uFF0C\u7528\u4E8E\u89C4\u5212\u5F00\u53D1\uFF1B**\u5B9E\u9645\u4E0A\u4F20\u4F53\u79EF\u4EE5\u7F16\u8BD1\u540E\u4E3A\u51C6**\uFF0C\u901A\u5E38\u4E0E\u6E90\u7801\u8D8B\u52BF\u4E00\u81F4\u3002
+
+### \u5F00\u53D1\u7EA6\u675F
+
+${rules}${warnings}`;
+}
+function renderMiniprogramFilledSectionEn(scan) {
+  const sizeTable = renderSizeTableEn(scan);
+  const rules = renderConstraintRulesEn(scan);
+  const warnings = scan.warnings.length ? `
+
+Scan notes: ${scan.warnings.join("; ")}` : "";
+  return `## Mini Program
+
+- Platform: ${scan.platformLabel}
+- Project type: ${scan.projectType}
+- Config: \`${scan.appJsonPath}\` (root \`${scan.miniprogramRoot}/\`)
+
+### Package size (source tree estimate; verify with WeChat DevTools / CI build output)
+
+${sizeTable}
+
+> These numbers sum source directories for planning. **Uploaded package size is determined by the build output**, but source trends usually match.
+
+### Development constraints
+
+${rules}${warnings}`;
+}
+function renderSizeTableZh(scan) {
+  const rows = [
+    renderPackageRowZh("\u4E3B\u5305", scan.mainPackage),
+    ...scan.subpackages.map((item) => renderPackageRowZh(`\u5206\u5305 ${item.name}`, item))
+  ];
+  rows.push(`| \u5408\u8BA1\uFF08\u6E90\u7801\u4F30\u7B97\uFF09 | \u2014 | ${formatBytes2(scan.totalSizeBytes)} | \u2264 ${TOTAL_LIMIT_MB} MB | \u53C2\u8003 |`);
+  return `| \u5305 | \u6839\u76EE\u5F55 | \u6E90\u7801\u4F53\u79EF\uFF08\u4F30\u7B97\uFF09 | \u4E0A\u9650 | \u72B6\u6001 |
+|----|--------|------------------|------|------|
+${rows.join("\n")}`;
+}
+function renderSizeTableEn(scan) {
+  const rows = [
+    renderPackageRowEn("main", scan.mainPackage),
+    ...scan.subpackages.map((item) => renderPackageRowEn(`subpackage ${item.name}`, item))
+  ];
+  rows.push(`| total (source estimate) | \u2014 | ${formatBytes2(scan.totalSizeBytes)} | \u2264 ${TOTAL_LIMIT_MB} MB | reference |`);
+  return `| package | root | estimated source size | limit | status |
+|---------|------|------------------------|-------|--------|
+${rows.join("\n")}`;
+}
+function renderPackageRowZh(label, pkg) {
+  return `| ${label} | \`${pkg.root}\` | ${pkg.sizeLabel} | \u2264 ${pkg.limitBytes / (1024 * 1024)} MB | ${statusLabelZh(pkg.status)} |`;
+}
+function renderPackageRowEn(label, pkg) {
+  return `| ${label} | \`${pkg.root}\` | ${pkg.sizeLabel} | \u2264 ${pkg.limitBytes / (1024 * 1024)} MB | ${statusLabelEn(pkg.status)} |`;
+}
+function renderConstraintRulesZh(scan) {
+  const blocked = collectBlockedPackages(scan);
+  const lines = [
+    `- \u5FAE\u4FE1\u5C0F\u7A0B\u5E8F\u4F53\u79EF\u4E0A\u9650\uFF08\u53D1\u5E03\u5230\u5FAE\u4FE1\u65F6\uFF09\uFF1A**\u4E3B\u5305 \u2264 ${MAIN_LIMIT_MB}MB**\uFF0C**\u5355\u4E2A\u5206\u5305 \u2264 ${SUB_LIMIT_MB}MB**\uFF0C**\u6574\u5305 \u2264 ${TOTAL_LIMIT_MB}MB**\uFF08\u4EE5[\u5FAE\u4FE1\u5B98\u65B9\u6587\u6863](https://developers.weixin.qq.com/miniprogram/dev/framework/subpackages.html)\u4E3A\u51C6\uFF09\u3002`,
+    `- **\u63A5\u8FD1\u4E0A\u9650\u9608\u503C\uFF1A\u6E90\u7801\u76EE\u5F55 \u2265 ${NEAR_LIMIT_MB}MB** \u5373\u89C6\u4E3A\u300C\u63A5\u8FD1 2MB\u300D\uFF1A\u7981\u6B62\u5728\u8BE5\u5305\u5185**\u65B0\u589E\u9875\u9762**\u3001\u5927\u56FE\u3001\u97F3\u89C6\u9891\u3001\u91CD\u590D\u9759\u6001\u8D44\u6E90\uFF1B\u4F18\u5148\u62C6\u5230\u5176\u4ED6\u5206\u5305\u3001\u61D2\u52A0\u8F7D\u6216\u5148\u505A\u4F53\u79EF\u4F18\u5316\u3002`,
+    `- \u4F53\u79EF **\u2265 ${MAIN_LIMIT_MB}MB\uFF08\u4E3B\u5305\uFF09\u6216 \u2265 ${SUB_LIMIT_MB}MB\uFF08\u5206\u5305\uFF09** \u65F6\uFF0C\u5FC5\u987B\u5148\u7626\u8EAB\u518D\u65B0\u589E\u529F\u80FD\u6216\u9875\u9762\u3002`,
+    `- \u65B0\u589E\u9875\u9762\u524D\uFF1A\u786E\u8BA4\u76EE\u6807\u5305\u4E0D\u5728\u300C\u63A5\u8FD1\u4E0A\u9650\u300D\u6216\u300C\u8D85\u9650\u300D\u5217\u8868\uFF1B\u8DE8\u5305\u8FC1\u79FB\u9875\u9762\u65F6\u540C\u6B65\u66F4\u65B0 \`app.json\` / \u5206\u5305\u914D\u7F6E\u4E0E\u8DEF\u7531\u5F15\u7528\u3002`,
+    `- Taro / uni-app \u53D1\u5E03\u5230\u5FAE\u4FE1\u65F6\u540C\u6837\u53D7\u4E0A\u8FF0\u4E0A\u4F20\u4F53\u79EF\u7EA6\u675F\uFF1B\u5176\u4ED6\u7AEF\u89C4\u5219\u89C1\u5BF9\u5E94\u5E73\u53F0\u6587\u6863\u3002`
+  ];
+  if (blocked.near.length) {
+    lines.push(
+      `- **\u5F53\u524D\u63A5\u8FD1\u4E0A\u9650\uFF08\u2265${NEAR_LIMIT_MB}MB\uFF0C\u7981\u6B62\u5728\u672C\u5305\u5185\u65B0\u589E\u9875\u9762\uFF09**\uFF1A${blocked.near.map((item) => `\`${item}\``).join("\u3001")}\u3002`
+    );
+  }
+  if (blocked.over.length) {
+    lines.push(`- **\u5F53\u524D\u5DF2\u8D85\u9650\uFF08\u5FC5\u987B\u5148\u7626\u8EAB\uFF09**\uFF1A${blocked.over.map((item) => `\`${item}\``).join("\u3001")}\u3002`);
+  }
+  if (!blocked.near.length && !blocked.over.length) {
+    lines.push("- \u5F53\u524D\u626B\u63CF\u672A\u53D1\u73B0\u63A5\u8FD1 2MB \u7684\u4E3B\u5305/\u5206\u5305\u76EE\u5F55\uFF0C\u4F46\u4ECD\u5E94\u5728\u6BCF\u6B21\u8F83\u5927\u6539\u52A8\u540E\u590D\u6838\u6784\u5EFA\u4EA7\u7269\u4F53\u79EF\u3002");
+  }
+  return lines.join("\n");
+}
+function renderConstraintRulesEn(scan) {
+  const blocked = collectBlockedPackages(scan);
+  const lines = [
+    `- WeChat upload limits: **main package \u2264 ${MAIN_LIMIT_MB}MB**, **each subpackage \u2264 ${SUB_LIMIT_MB}MB**, **whole mini program \u2264 ${TOTAL_LIMIT_MB}MB** (see WeChat official docs).`,
+    `- Treat **source tree \u2265 ${NEAR_LIMIT_MB}MB** as near the 2MB cap: do **not** add new pages, large media, or redundant static assets in that package; split work to another subpackage or optimize first.`,
+    `- If a package is **\u2265 ${MAIN_LIMIT_MB}MB (main) or \u2265 ${SUB_LIMIT_MB}MB (sub)** , optimize before adding pages or features.`,
+    `- Before adding a page, confirm the target package is not listed below; update \`app.json\` / subpackage config when moving pages.`,
+    `- Taro / uni-app builds for WeChat follow the same upload limits.`
+  ];
+  if (blocked.near.length) {
+    lines.push(`- **Near limit (\u2265${NEAR_LIMIT_MB}MB, no new pages in these packages):** ${blocked.near.map((item) => `\`${item}\``).join(", ")}.`);
+  }
+  if (blocked.over.length) {
+    lines.push(`- **Over limit (optimize before more work):** ${blocked.over.map((item) => `\`${item}\``).join(", ")}.`);
+  }
+  if (!blocked.near.length && !blocked.over.length) {
+    lines.push("- No package is near 2MB in this scan; still verify build output after large changes.");
+  }
+  return lines.join("\n");
+}
+function collectBlockedPackages(scan) {
+  const near = [];
+  const over = [];
+  const all = [scan.mainPackage, ...scan.subpackages];
+  for (const pkg of all) {
+    const label = pkg.name === "main" ? `\u4E3B\u5305(${pkg.root})` : `${pkg.name}(${pkg.root})`;
+    if (pkg.status === "over_limit") {
+      over.push(label);
+    } else if (pkg.status === "near_limit") {
+      near.push(label);
+    }
+  }
+  return { near, over };
+}
+function statusLabelZh(status) {
+  if (status === "over_limit") {
+    return "\u8D85\u9650";
+  }
+  if (status === "near_limit") {
+    return "\u63A5\u8FD1\u4E0A\u9650";
+  }
+  return "\u6B63\u5E38";
+}
+function statusLabelEn(status) {
+  if (status === "over_limit") {
+    return "over limit";
+  }
+  if (status === "near_limit") {
+    return "near limit";
+  }
+  return "ok";
+}
+function formatBytes2(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+function renderMiniprogramNotApplicableSection(language) {
+  if (language === "en") {
+    return `## Mini Program
+
+Not detected as a mini program project. Leave this section as N/A or remove it if irrelevant.`;
+  }
+  return `## \u5C0F\u7A0B\u5E8F
+
+\u672A\u8BC6\u522B\u4E3A\u5C0F\u7A0B\u5E8F\u5DE5\u7A0B\uFF1B\u5982\u65E0\u5C0F\u7A0B\u5E8F\u573A\u666F\u53EF\u586B\u5199\u300C\u4E0D\u9002\u7528\u300D\u6216\u5220\u9664\u672C\u8282\u3002`;
+}
+function patchAgentsMiniprogramSection(content, sectionMarkdown, language) {
+  const heading = language === "en" ? "## Mini Program" : "## \u5C0F\u7A0B\u5E8F";
+  const autoBegin = "<!-- FET:BEGIN AUTO -->";
+  const autoEnd = "<!-- FET:END AUTO -->";
+  const begin = content.indexOf(autoBegin);
+  const end = content.indexOf(autoEnd);
+  if (begin === -1 || end === -1 || end < begin) {
+    return content;
+  }
+  const auto = content.slice(begin, end);
+  const headingIndex = auto.indexOf(heading);
+  if (headingIndex === -1) {
+    const insertion = `
+
+${sectionMarkdown}
+`;
+    return `${content.slice(0, end)}${insertion}${content.slice(end)}`;
+  }
+  const afterHeading = auto.slice(headingIndex + heading.length);
+  const nextHeading = afterHeading.search(/\n## /);
+  const sectionEnd = nextHeading === -1 ? auto.length : headingIndex + heading.length + nextHeading;
+  const absoluteStart = begin + headingIndex;
+  const absoluteEnd = begin + sectionEnd;
+  return `${content.slice(0, absoluteStart)}${sectionMarkdown}${content.slice(absoluteEnd)}`;
+}
+
+// src/agents-miniprogram.ts
+async function applyMiniprogramAgentsContext(projectRoot, language) {
+  const agentsPath = join9(projectRoot, "AGENTS.md");
+  const detection = await detectMiniprogramProject(projectRoot);
+  let existing;
+  try {
+    existing = await readFile7(agentsPath, "utf8");
+  } catch {
+    return {
+      applied: false,
+      detection,
+      summary: language === "en" ? "AGENTS.md was not found." : "\u672A\u627E\u5230 AGENTS.md\u3002"
+    };
+  }
+  const section = detection.supported ? renderMiniprogramFilledSection(detection, language) : renderMiniprogramNotApplicableSection(language);
+  const next = patchAgentsMiniprogramSection(existing, section, language);
+  if (next === existing) {
+    return {
+      applied: false,
+      detection,
+      summary: language === "en" ? "AGENTS.md mini program section was unchanged." : "AGENTS.md \u5C0F\u7A0B\u5E8F\u8282\u672A\u53D8\u66F4\u3002"
+    };
+  }
+  await atomicWrite(agentsPath, next);
+  if (!detection.supported) {
+    return {
+      applied: true,
+      detection,
+      summary: language === "en" ? "Marked mini program section as not applicable." : "\u5DF2\u5C06\u5C0F\u7A0B\u5E8F\u8282\u6807\u8BB0\u4E3A\u4E0D\u9002\u7528\u3002"
+    };
+  }
+  const near = [detection.mainPackage, ...detection.subpackages].filter((pkg) => pkg.status !== "ok");
+  const summary = language === "en" ? near.length ? `Updated AGENTS.md mini program constraints (${near.length} package(s) near or over limit).` : "Updated AGENTS.md mini program constraints and package size table." : near.length ? `\u5DF2\u66F4\u65B0 AGENTS.md \u5C0F\u7A0B\u5E8F\u7EA6\u675F\uFF08${near.length} \u4E2A\u5305\u63A5\u8FD1\u6216\u8D85\u8FC7\u4F53\u79EF\u4E0A\u9650\uFF09\u3002` : "\u5DF2\u66F4\u65B0 AGENTS.md \u5C0F\u7A0B\u5E8F\u5305\u4F53\u79EF\u8868\u4E0E\u5F00\u53D1\u7EA6\u675F\u3002";
+  return { applied: true, detection, summary };
+}
+
+// src/commands/fill-context.ts
 async function fillContextCommand(ctx) {
+  let miniprogramSummary;
   await withProjectLock(ctx.projectRoot, { command: "fill-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
-    const handoffPath = join7(ctx.projectRoot, ".fet", "fill-context.md");
+    const miniprogramResult = await applyMiniprogramAgentsContext(ctx.projectRoot, ctx.language);
+    miniprogramSummary = miniprogramResult.summary;
+    const handoffPath = join10(ctx.projectRoot, ".fet", "fill-context.md");
     await mkdir3(dirname4(handoffPath), { recursive: true });
-    await atomicWrite(handoffPath, renderGenericHandoff(ctx.language));
+    await atomicWrite(handoffPath, renderGenericHandoff(ctx.language, miniprogramResult.detection.supported));
     for (const adapter of ctx.toolAdapters) {
       const plan = await adapter.planInstall(ctx.projectRoot, ctx.language);
       const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
@@ -388,10 +1046,12 @@ async function fillContextCommand(ctx) {
     }
   });
   const placeholders = await countAgentsLlmPlaceholders(ctx.projectRoot);
+  const warnings = miniprogramSummary ? [miniprogramSummary] : void 0;
   ctx.output.result({
     ok: true,
     command: "fill-context",
-    summary: ctx.language === "en" ? placeholders ? `Found ${placeholders} AGENTS.md placeholder(s). Use your IDE AI to fill them.` : "No AGENTS.md placeholders found. IDE fill-context commands were refreshed." : placeholders ? `\u53D1\u73B0 ${placeholders} \u4E2A AGENTS.md \u5360\u4F4D\u7B26\u3002\u8BF7\u4F7F\u7528 IDE AI \u8865\u9F50\u3002` : "\u672A\u53D1\u73B0 AGENTS.md \u5360\u4F4D\u7B26\uFF0C\u5DF2\u5237\u65B0 IDE fill-context \u547D\u4EE4\u3002",
+    summary: ctx.language === "en" ? placeholders ? `Found ${placeholders} AGENTS.md placeholder(s). Use your IDE AI to fill the rest.` : "AGENTS.md placeholders are complete. IDE fill-context commands were refreshed." : placeholders ? `\u53D1\u73B0 ${placeholders} \u4E2A AGENTS.md \u5360\u4F4D\u7B26\u3002\u8BF7\u4F7F\u7528 IDE AI \u8865\u9F50\u5176\u4F59\u90E8\u5206\u3002` : "AGENTS.md \u5360\u4F4D\u7B26\u5DF2\u8865\u9F50\uFF0C\u5DF2\u5237\u65B0 IDE fill-context \u547D\u4EE4\u3002",
+    warnings,
     nextSteps: ctx.language === "en" ? placeholders ? [
       "Cursor: run /fet-fill-context",
       "Codex: run /prompts:fet-fill-context",
@@ -408,7 +1068,9 @@ async function fillContextCommand(ctx) {
     }
   });
 }
-function renderGenericHandoff(language) {
+function renderGenericHandoff(language, miniprogramDetected) {
+  const miniprogramNoteEn = miniprogramDetected ? "FET already scanned the mini program layout and wrote package-size constraints into AGENTS.md. Do not overwrite the Mini Program / package-size / development-constraint subsections unless the repo changed." : "If AGENTS.md has a Mini Program section marked not applicable, keep it unless the project is actually a mini program.";
+  const miniprogramNoteZh = miniprogramDetected ? "FET \u5DF2\u626B\u63CF\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u5E76\u628A\u5305\u4F53\u79EF/\u5F00\u53D1\u7EA6\u675F\u5199\u5165 AGENTS.md\u3002\u9664\u975E\u4ED3\u5E93\u7ED3\u6784\u5DF2\u53D8\uFF0C\u4E0D\u8981\u8986\u76D6\u300C\u5C0F\u7A0B\u5E8F\u300D\u8282\u4E2D\u7684\u5305\u4F53\u79EF\u8868\u4E0E\u5F00\u53D1\u7EA6\u675F\u3002" : "\u82E5 AGENTS.md \u5C0F\u7A0B\u5E8F\u8282\u5DF2\u6807\u8BB0\u4E3A\u4E0D\u9002\u7528\uFF0C\u4E14\u9879\u76EE\u786E\u5B9E\u4E0D\u662F\u5C0F\u7A0B\u5E8F\uFF0C\u53EF\u4FDD\u7559\u8BE5\u8BF4\u660E\u3002";
   if (language === "en") {
     return `<!-- FET:MANAGED
 schemaVersion: 1
@@ -422,10 +1084,11 @@ Use the IDE AI to complete FET-generated placeholders.
 1. Read AGENTS.md and openspec/config.yaml.
 2. Read .fet/karpathy-guidelines.md when it exists. For Codex, also read .codex/fet/karpathy-guidelines.md when it exists.
 3. Inspect README files, package scripts, routes, tests, source layout, and project conventions.
-4. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content.
-5. Preserve FET managed markers.
-6. Do not modify business code.
-7. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
+4. ${miniprogramNoteEn}
+5. Replace every remaining \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete project-specific content.
+6. Preserve FET managed markers.
+7. Do not modify business code.
+8. Run \`fet doctor\` and confirm no AGENTS.md placeholder warning remains.
 `;
   }
   return `<!-- FET:MANAGED
@@ -440,20 +1103,21 @@ FET:END -->
 1. \u9605\u8BFB AGENTS.md \u548C openspec/config.yaml\u3002
 2. \u5982\u679C\u5B58\u5728 .fet/karpathy-guidelines.md\uFF0C\u8BF7\u4E00\u5E76\u9605\u8BFB\u3002\u5BF9 Codex\uFF0C\u5982\u679C\u5B58\u5728 .codex/fet/karpathy-guidelines.md\uFF0C\u4E5F\u8981\u9605\u8BFB\u3002
 3. \u68C0\u67E5 README\u3001package scripts\u3001\u8DEF\u7531\u3001\u6D4B\u8BD5\u3001\u6E90\u7801\u7ED3\u6784\u548C\u9879\u76EE\u7EA6\u5B9A\u3002
-4. \u5C06 AGENTS.md \u4E2D\u6BCF\u4E2A \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002
-5. \u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\u3002
-6. \u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
-7. \u8FD0\u884C \`fet doctor\`\uFF0C\u786E\u8BA4\u4E0D\u518D\u6709 AGENTS.md \u5360\u4F4D\u7B26\u8B66\u544A\u3002
+4. ${miniprogramNoteZh}
+5. \u5C06\u5176\u4F59 \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002
+6. \u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\u3002
+7. \u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
+8. \u8FD0\u884C \`fet doctor\`\uFF0C\u786E\u8BA4\u4E0D\u518D\u6709 AGENTS.md \u5360\u4F4D\u7B26\u8B66\u544A\u3002
 `;
 }
 
 // src/commands/graph.ts
 import { mkdir as mkdir5 } from "fs/promises";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname6, join as join12 } from "path";
 
 // src/graph-context.ts
-import { mkdir as mkdir4, readdir, readFile as readFile5 } from "fs/promises";
-import { dirname as dirname5, join as join8 } from "path";
+import { mkdir as mkdir4, readdir as readdir2, readFile as readFile8 } from "fs/promises";
+import { dirname as dirname5, join as join11 } from "path";
 var MAX_SOURCE_CONTEXT = 8e3;
 var MAX_GRAPH_OUTPUT = 2e4;
 async function buildProjectGraphContext(ctx, state, trigger) {
@@ -472,7 +1136,7 @@ async function buildProjectGraphContext(ctx, state, trigger) {
   const warnings = commandWarnings([["gitnexus query", graphQuery], ["gitnexus status", status]]);
   const relativePath = ".fet/graph-context/project.md";
   await writeGraphContext(
-    join8(ctx.projectRoot, relativePath),
+    join11(ctx.projectRoot, relativePath),
     renderProjectContext({
       trigger,
       state,
@@ -520,7 +1184,7 @@ async function buildWorkflowGraphContext(ctx, options) {
   ]);
   const relativePath = `.fet/graph-context/${sanitizePathPart(options.changeId ?? options.command)}.md`;
   await writeGraphContext(
-    join8(ctx.projectRoot, relativePath),
+    join11(ctx.projectRoot, relativePath),
     renderWorkflowContext({
       state,
       command: options.command,
@@ -666,16 +1330,16 @@ async function collectOpenSpecContext(projectRoot, changeId) {
   if (!changeId) {
     return "";
   }
-  const changeRoot = join8(projectRoot, "openspec", "changes", changeId);
+  const changeRoot = join11(projectRoot, "openspec", "changes", changeId);
   const chunks = [];
   for (const file of ["proposal.md", "design.md", "tasks.md", "README.md"]) {
-    const content = await readOptional(join8(changeRoot, file));
+    const content = await readOptional(join11(changeRoot, file));
     if (content) {
       chunks.push(`## ${file}
 ${content}`);
     }
   }
-  const specsRoot = join8(changeRoot, "specs");
+  const specsRoot = join11(changeRoot, "specs");
   for (const spec of await listSpecFiles(specsRoot)) {
     const content = await readOptional(spec.path);
     if (content) {
@@ -687,9 +1351,9 @@ ${content}`);
 }
 async function listSpecFiles(specsRoot) {
   try {
-    const capabilities = await readdir(specsRoot, { withFileTypes: true });
+    const capabilities = await readdir2(specsRoot, { withFileTypes: true });
     return capabilities.filter((entry) => entry.isDirectory()).map((entry) => ({
-      path: join8(specsRoot, entry.name, "spec.md"),
+      path: join11(specsRoot, entry.name, "spec.md"),
       label: `specs/${entry.name}/spec.md`
     }));
   } catch {
@@ -698,7 +1362,7 @@ async function listSpecFiles(specsRoot) {
 }
 async function readOptional(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch {
     return null;
   }
@@ -809,7 +1473,7 @@ async function graphDoctorCommand(ctx) {
 }
 async function graphSetupCommand(ctx) {
   let result;
-  const handoffPath = join9(ctx.projectRoot, ".fet", "graph-setup.md");
+  const handoffPath = join12(ctx.projectRoot, ".fet", "graph-setup.md");
   const installCommand = process.env.FET_GITNEXUS_INSTALL_COMMAND?.trim() || null;
   await withProjectLock(ctx.projectRoot, { command: "graph setup", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
     result = await refreshGraphState(ctx, { write: false });
@@ -845,7 +1509,7 @@ async function graphSetupCommand(ctx) {
 }
 async function graphHandoffCommand(ctx) {
   let result;
-  const handoffPath = join9(ctx.projectRoot, ".fet", "graph-handoff.md");
+  const handoffPath = join12(ctx.projectRoot, ".fet", "graph-handoff.md");
   await withProjectLock(ctx.projectRoot, { command: "graph handoff", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
     result = await refreshGraphState(ctx, { runStatus: true, write: false });
     await writeHandoffFile(handoffPath, renderGraphUsageHandoff(result.state, ctx.language));
@@ -1100,19 +1764,41 @@ function firstLine2(value) {
 }
 
 // src/commands/init.ts
-import { readFile as readFile8, stat as stat4 } from "fs/promises";
-import { join as join12 } from "path";
+import { stat as stat6 } from "fs/promises";
+import { join as join15 } from "path";
+
+// src/commands/update-context.ts
+import { readFile as readFile10 } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { join as join14 } from "path";
+
+// src/config/yaml.ts
+import { readFile as readFile9 } from "fs/promises";
+import { parseDocument } from "yaml";
+async function mergeFetConfig(configPath, renderedFetYaml) {
+  const fetDoc = parseDocument(renderedFetYaml);
+  const nextFet = fetDoc.get("fet", true);
+  let existing = "";
+  try {
+    existing = await readFile9(configPath, "utf8");
+  } catch {
+    return renderedFetYaml;
+  }
+  const doc = parseDocument(existing || "{}");
+  doc.set("fet", nextFet);
+  return doc.toString();
+}
 
 // src/version.ts
 import { existsSync, readFileSync } from "fs";
-import { dirname as dirname7, join as join10, parse } from "path";
+import { dirname as dirname7, join as join13, parse as parse2 } from "path";
 import { fileURLToPath } from "url";
 var FET_VERSION = readPackageVersion();
 function readPackageVersion() {
   let currentDir = dirname7(fileURLToPath(import.meta.url));
-  const root = parse(currentDir).root;
+  const root = parse2(currentDir).root;
   while (true) {
-    const packageJsonPath = join10(currentDir, "package.json");
+    const packageJsonPath = join13(currentDir, "package.json");
     if (existsSync(packageJsonPath)) {
       const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
       if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
@@ -1191,6 +1877,12 @@ function sectionKey(heading) {
     "ai \u5DE5\u4F5C\u6307\u5357": "ai-guidelines",
     "scanner metadata": "metadata",
     "\u626B\u63CF\u5143\u6570\u636E": "metadata",
+    "mini program": "miniprogram",
+    "\u5C0F\u7A0B\u5E8F": "miniprogram",
+    "package size (filled by `fet fill-context`)": "miniprogram-size",
+    "\u5305\u4F53\u79EF\uFF08\u7531 `fet fill-context` \u626B\u63CF\u8865\u5145\uFF09": "miniprogram-size",
+    "development constraints": "miniprogram-rules",
+    "\u5F00\u53D1\u7EA6\u675F": "miniprogram-rules",
     "notes for ai": "notes",
     "\u7ED9 ai \u7684\u5907\u6CE8": "notes"
   };
@@ -1271,6 +1963,8 @@ ${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
 
 [NEEDS LLM INPUT]
 
+${renderMiniprogramPlaceholderSection("zh-CN")}
+
 ## AI \u5DE5\u4F5C\u6307\u5357
 
 - \u4F7F\u7528 FET \u6258\u7BA1\u7684 IDE \u5DE5\u4F5C\u6D41\u65F6\uFF0C\u4F18\u5148\u53C2\u8003 .fet/karpathy-guidelines.md \u4E2D\u7684\u9879\u76EE\u7EA7\u6307\u5357\u3002
@@ -1334,6 +2028,8 @@ ${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
 
 [NEEDS LLM INPUT]
 
+${renderMiniprogramPlaceholderSection("en")}
+
 ## AI Work Guidelines
 
 - Prefer the project-level Andrej Karpathy inspired guidelines in .fet/karpathy-guidelines.md when using FET-managed IDE workflows.
@@ -1383,6 +2079,10 @@ function renderFetConfig(scan, language = "zh-CN") {
           test: "warn"
         },
         workspaces: scan.project.workspaces
+      },
+      figmaGuard: {
+        enabled: true,
+        onUncertainty: "stop_and_ask"
       }
     }
   });
@@ -1535,64 +2235,124 @@ purpose: manual-verify
 2. \u6309\u9879\u76EE\u7EA6\u5B9A\u8FD0\u884C lint\u3001typecheck\u3001test\u3002
 3. \u68C0\u67E5\u672C\u6B21 change \u7684 \`tasks.md\` \u662F\u5426\u4E0E\u5B9E\u73B0\u72B6\u6001\u4E00\u81F4\u3002
 
-\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+
+\`\`\`sh
+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}
 
-\`\`\`sh
-fet verify --done --change ${changeId}
-\`\`\`
-`;
-}
+## Sources
 
-// src/templates/gitignore.ts
-var BEGIN2 = "# FET:BEGIN LOCAL STATE";
-var END2 = "# FET:END LOCAL STATE";
-var RULES = [
-  "openspec/fet-state.json",
-  "openspec/.fet.lock",
-  "openspec/.fet-init-journal.json",
-  "openspec/changes/*/fet-state.json",
-  "openspec/changes/*/.fet/",
-  ".gitnexus/"
-];
-function mergeGitignore(existing) {
-  const block = `${BEGIN2}
-${RULES.join("\n")}
-${END2}`;
-  if (!existing || !existing.trim()) {
-    return `${block}
-`;
-  }
-  const start = existing.indexOf(BEGIN2);
-  const end = existing.indexOf(END2);
-  if (start !== -1 && end !== -1 && end > start) {
-    return `${existing.slice(0, start)}${block}${existing.slice(end + END2.length)}`;
-  }
-  return `${existing.replace(/\s*$/, "")}
+${sourceList}
 
-${block}
+${renderFigmaStopProtocolBody(options.language)}
 `;
 }
-
-// src/commands/update-context.ts
-import { readFile as readFile7 } from "fs/promises";
-import { createInterface } from "readline/promises";
-import { join as join11 } from "path";
-
-// src/config/yaml.ts
-import { readFile as readFile6 } from "fs/promises";
-import { parseDocument } from "yaml";
-async function mergeFetConfig(configPath, renderedFetYaml) {
-  const fetDoc = parseDocument(renderedFetYaml);
-  const nextFet = fetDoc.get("fet", true);
-  let existing = "";
-  try {
-    existing = await readFile6(configPath, "utf8");
-  } catch {
-    return renderedFetYaml;
-  }
-  const doc = parseDocument(existing || "{}");
-  doc.set("fet", nextFet);
-  return doc.toString();
+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
@@ -1610,11 +2370,11 @@ async function updateContextCommand(ctx) {
 }
 async function updateContextFiles(ctx) {
   const scan = await ctx.scanner.scan(ctx.projectRoot, {});
-  const agentsPath = join11(ctx.projectRoot, "AGENTS.md");
-  const configPath = join11(ctx.projectRoot, "openspec", "config.yaml");
-  const claudePath = join11(ctx.projectRoot, "CLAUDE.md");
-  const karpathyHandoffPath = join11(ctx.projectRoot, ".fet", "karpathy-guidelines.md");
-  const karpathyCursorPath = join11(ctx.projectRoot, ".cursor", "rules", "karpathy-guidelines.mdc");
+  const agentsPath = join14(ctx.projectRoot, "AGENTS.md");
+  const configPath = join14(ctx.projectRoot, "openspec", "config.yaml");
+  const claudePath = join14(ctx.projectRoot, "CLAUDE.md");
+  const karpathyHandoffPath = join14(ctx.projectRoot, ".fet", "karpathy-guidelines.md");
+  const karpathyCursorPath = join14(ctx.projectRoot, ".cursor", "rules", "karpathy-guidelines.mdc");
   const existingAgents = await readOptional2(agentsPath);
   const existingClaude = await readOptional2(claudePath);
   const existingKarpathyCursor = await readOptional2(karpathyCursorPath);
@@ -1688,7 +2448,7 @@ async function confirmInitCanReplaceUnmanagedAgents(ctx) {
 }
 async function readOptional2(path) {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch {
     return null;
   }
@@ -1696,7 +2456,7 @@ async function readOptional2(path) {
 
 // src/commands/init.ts
 async function initCommand(ctx) {
-  const alreadyInitialized = await exists2(join12(ctx.projectRoot, "openspec", "config.yaml"));
+  const alreadyInitialized = await exists4(join15(ctx.projectRoot, "openspec", "config.yaml"));
   let warnings = [];
   await withProjectLock(ctx.projectRoot, { command: "init", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
     const journal = createInitJournal(ctx.fetVersion);
@@ -1711,7 +2471,6 @@ async function initCommand(ctx) {
     }
     const contextResult = await updateContextFiles(ctx);
     warnings = contextResult.warnings;
-    await ensureGitignore(ctx);
     const state = await ctx.stateStore.getOrCreateGlobal();
     state.openspec = identity;
     state.language = {
@@ -1747,30 +2506,138 @@ async function initCommand(ctx) {
     nextSteps: ctx.language === "en" ? ["Use fet propose/new to create an OpenSpec change", "Use fet doctor to check project health"] : ["\u4F7F\u7528 fet propose/new \u521B\u5EFA OpenSpec change", "\u4F7F\u7528 fet doctor \u68C0\u67E5\u9879\u76EE\u72B6\u6001"]
   });
 }
-async function ensureGitignore(ctx) {
-  const gitignorePath = join12(ctx.projectRoot, ".gitignore");
-  const existing = await readOptional3(gitignorePath);
-  await atomicWrite(gitignorePath, mergeGitignore(existing));
+async function exists4(path) {
+  try {
+    await stat6(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
-async function readOptional3(path) {
+
+// src/commands/proxy.ts
+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 {
-    return await readFile8(path, "utf8");
+    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 exists2(path) {
+async function listMarkdownFiles(root) {
+  const files = [];
+  await walk(root, files);
+  return files;
+}
+async function walk(dir, files) {
   try {
-    await stat4(path);
-    return true;
+    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 false;
+    return;
+  }
+}
+async function readOptional3(path) {
+  try {
+    await stat7(path);
+    return await readFile11(path, "utf8");
+  } catch {
+    return null;
   }
 }
-
-// src/commands/proxy.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join14 } from "path";
 
 // src/state/project.ts
 import { execFile as execFile2 } from "child_process";
@@ -1799,8 +2666,8 @@ async function git(cwd, args) {
 }
 
 // src/state/store.ts
-import { mkdir as mkdir6, readFile as readFile9 } from "fs/promises";
-import { join as join13 } 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";
@@ -1918,7 +2785,7 @@ var StateStore = class {
   project;
   async readGlobal() {
     try {
-      const value = JSON.parse(await readFile9(this.globalPath(), "utf8"));
+      const value = JSON.parse(await readFile12(this.globalPath(), "utf8"));
       assertGlobalState(value);
       return value;
     } catch (error) {
@@ -1933,13 +2800,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join13(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 readFile9(this.changePath(changeId), "utf8"));
+      const value = JSON.parse(await readFile12(this.changePath(changeId), "utf8"));
       assertChangeState(value);
       return value;
     } catch (error) {
@@ -1954,15 +2821,15 @@ var StateStore = class {
   }
   async writeChange(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join13(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 join13(this.projectRoot, "openspec", "fet-state.json");
+    return join17(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join13(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join17(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -1970,11 +2837,11 @@ function isNotFound(error) {
 }
 
 // src/state/tasks.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 async function readCompletedTaskIds(tasksPath) {
   let content;
   try {
-    content = await readFile10(tasksPath, "utf8");
+    content = await readFile13(tasksPath, "utf8");
   } catch {
     return [];
   }
@@ -2123,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
       }
     });
   });
@@ -2150,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) {
@@ -2280,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
       }
     });
   });
@@ -2502,7 +3398,7 @@ async function createChangelogEntry(projectRoot, changeId) {
   };
 }
 async function appendChangelog(projectRoot, entry) {
-  const changelogPath = join14(projectRoot, "CHANGELOG.md");
+  const changelogPath = join18(projectRoot, "CHANGELOG.md");
   const existing = await readOptional4(changelogPath);
   const legacyContentLabel = "\u66F4\u65B0\u5185\u5BB9";
   const block = `updateTime: ${entry.updateTime}
@@ -2515,12 +3411,12 @@ ${block}` : block;
   await atomicWrite(changelogPath, next);
 }
 async function readChangeRequirement(projectRoot, changeId) {
-  const changeRoot = join14(projectRoot, "openspec", "changes", changeId);
-  const proposal = await readOptional4(join14(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 readOptional4(join14(changeRoot, "README.md"));
+  const readme = await readOptional4(join18(changeRoot, "README.md"));
   if (readme) {
     return summarizeMarkdown(readme);
   }
@@ -2532,7 +3428,7 @@ function summarizeMarkdown(content) {
 }
 async function readOptional4(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch {
     return null;
   }
@@ -2888,8 +3784,8 @@ async function updateCommand(ctx) {
 
 // src/commands/verify.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir7, readFile as readFile12, stat as stat5 } from "fs/promises";
-import { join as join15 } 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, {});
@@ -2956,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 = join15(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
-  const instructionsPath = join15(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");
@@ -2974,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 = join15(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");
@@ -3009,8 +3905,8 @@ async function assertChangeExists(ctx, changeId) {
 }
 async function readInstructions(path, changeId) {
   try {
-    await stat5(path);
-    const content = await readFile12(path, "utf8");
+    await stat8(path);
+    const content = await readFile15(path, "utf8");
     const fileChangeId = readFrontMatterValue(content, "changeId");
     if (fileChangeId !== changeId) {
       throw new FetError({
@@ -3148,9 +4044,9 @@ function renderIdeModelPolicy(command, language = "zh-CN") {
 import { resolve } from "path";
 
 // src/adapters/codex/index.ts
-import { mkdir as mkdir8, readFile as readFile13, stat as stat6 } 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 join16 } from "path";
+import { dirname as dirname8, join as join20 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -3192,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.
@@ -3210,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
@@ -3230,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)
@@ -3583,7 +4488,7 @@ ${commandGoalZh(command)}
 - \u9ED8\u8BA4\u4F7F\u7528\u4E2D\u6587\u4EA7\u51FA\u3002
 - \u4E0D\u8981\u7ED5\u8FC7 FET \u76F4\u63A5\u8C03\u7528 openspec\uFF0C\u9664\u975E FET \u547D\u4EE4\u672C\u8EAB\u4E0D\u53EF\u7528\u3002
 - change \u4E0D\u660E\u786E\u65F6\u5148\u8BE2\u95EE\u7528\u6237\u3002
-${command === "fill-context" ? "- \u66FF\u6362 AGENTS.md \u4E2D\u6BCF\u4E2A `[NEEDS LLM INPUT]` \u6216 `[NEED LLM INPUT]` \u5360\u4F4D\u7B26\uFF0C\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002\n" : ""}${command === "propose" || command === "continue" ? "- \u4E00\u6B21\u53EA\u521B\u5EFA\u4E00\u4E2A ready artifact\uFF0C\u5E76\u5728\u5199\u5165\u524D\u9605\u8BFB\u4F9D\u8D56\u6587\u4EF6\u3002\n" : ""}${command === "propose" || command === "continue" ? "- \u4E0D\u8981\u5728\u7528\u6237\u5BA1\u9605\u5F53\u524D\u4EA7\u7269\u524D\u81EA\u52A8\u8FD0\u884C fet continue\u3001fet ff \u6216\u5FAA\u73AF\u751F\u6210\u540E\u7EED\u4EA7\u7269\uFF1B\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u518D\u63A8\u8FDB\u3002\n" : ""}${command === "apply" ? "- \u4E0D\u8981\u5728\u672A\u5B8C\u6210\u771F\u5B9E\u5B9E\u73B0\u524D\u52FE\u9009 tasks.md\uFF1B\u4E0D\u8981\u4ECE apply \u9636\u6BB5\u76F4\u63A5 sync \u6216 archive\u3002\n" : ""}`;
+${command === "fill-context" ? "- fet fill-context \u53EF\u80FD\u5DF2\u5199\u5165\u5C0F\u7A0B\u5E8F\u5305\u4F53\u79EF\u4E0E 2MB \u7EA6\u675F\uFF0C\u4E0D\u8981\u8986\u76D6\u8BE5\u8282\u4E2D\u7684\u626B\u63CF\u7ED3\u679C\uFF0C\u9664\u975E\u4ED3\u5E93\u7ED3\u6784\u5DF2\u53D8\u3002\n- \u66FF\u6362 AGENTS.md \u4E2D\u5176\u4F59 [NEEDS LLM INPUT] \u5360\u4F4D\u7B26\uFF0C\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002\n" : ""}${command === "propose" || command === "continue" ? "- \u4E00\u6B21\u53EA\u521B\u5EFA\u4E00\u4E2A ready artifact\uFF0C\u5E76\u5728\u5199\u5165\u524D\u9605\u8BFB\u4F9D\u8D56\u6587\u4EF6\u3002\n" : ""}${command === "propose" || command === "continue" ? "- \u4E0D\u8981\u5728\u7528\u6237\u5BA1\u9605\u5F53\u524D\u4EA7\u7269\u524D\u81EA\u52A8\u8FD0\u884C fet continue\u3001fet ff \u6216\u5FAA\u73AF\u751F\u6210\u540E\u7EED\u4EA7\u7269\uFF1B\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u518D\u63A8\u8FDB\u3002\n" : ""}${command === "apply" ? "- \u4E0D\u8981\u5728\u672A\u5B8C\u6210\u771F\u5B9E\u5B9E\u73B0\u524D\u52FE\u9009 tasks.md\uFF1B\u4E0D\u8981\u4ECE apply \u9636\u6BB5\u76F4\u63A5 sync \u6216 archive\u3002\n" : ""}`;
 }
 function commandTitleZh(command) {
   const titles = {
@@ -3680,10 +4585,11 @@ Steps:
    - scripts, test commands, and build commands
    - coding conventions and project-specific patterns
    - important docs such as README files
-5. Replace every \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete, concise project-specific content.
-6. Preserve FET managed markers such as \`FET:BEGIN AUTO\`, \`FET:END AUTO\`, \`FET:BEGIN USER\`, and \`FET:END USER\`.
-7. Do not modify business code.
-8. Run:
+5. \`fet fill-context\` may already fill the mini program package-size table and 2MB constraints. Do not overwrite those subsections unless the repo changed.
+6. Replace every remaining \`[NEEDS LLM INPUT]\` or \`[NEED LLM INPUT]\` placeholder in AGENTS.md with concrete, concise project-specific content.
+7. Preserve FET managed markers such as \`FET:BEGIN AUTO\`, \`FET:END AUTO\`, \`FET:BEGIN USER\`, and \`FET:END USER\`.
+8. Do not modify business code.
+9. Run:
    \`\`\`sh
    fet doctor
    \`\`\`
@@ -4190,7 +5096,7 @@ var CodexAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists3(join16(projectRoot, ".codex")) || await exists3(join16(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"
     };
   }
@@ -4256,9 +5162,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join16(resolveCodexHome(), file.path);
+    return join20(resolveCodexHome(), file.path);
   }
-  return join16(projectRoot, file.path);
+  return join20(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -4267,18 +5173,18 @@ function displayPathFor(file) {
   return file.path;
 }
 function resolveCodexHome() {
-  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join16(homedir(), ".codex");
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join20(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile16(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists3(path) {
+async function exists5(path) {
   try {
-    await stat6(path);
+    await stat9(path);
     return true;
   } catch {
     return false;
@@ -4286,10 +5192,19 @@ async function exists3(path) {
 }
 
 // src/adapters/cursor/index.ts
-import { mkdir as mkdir9, readFile as readFile14, stat as stat7 } from "fs/promises";
-import { dirname as dirname9, join as join17 } 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`,
@@ -4319,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
 `
@@ -4352,7 +5268,9 @@ ${languageInstruction(language)}
 - AGENTS.md
 - openspec/config.yaml
 
-\u68C0\u67E5 README\u3001package scripts\u3001\u8DEF\u7531\u3001\u6D4B\u8BD5\u3001\u6E90\u7801\u7ED3\u6784\u548C\u73B0\u6709\u7EA6\u5B9A\u540E\uFF0C\u628A AGENTS.md \u4E2D\u6BCF\u4E2A \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u7B80\u6D01\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
+\`fet fill-context\` \u53EF\u80FD\u5DF2\u5199\u5165\u5C0F\u7A0B\u5E8F\u5305\u4F53\u79EF\u8868\u4E0E 2MB \u5F00\u53D1\u7EA6\u675F\uFF0C\u4E0D\u8981\u8986\u76D6 AGENTS.md\u300C\u5C0F\u7A0B\u5E8F\u300D\u8282\u4E2D\u7684\u626B\u63CF\u7ED3\u679C\uFF0C\u9664\u975E\u4ED3\u5E93\u7ED3\u6784\u5DF2\u53D8\u3002
+
+\u68C0\u67E5 README\u3001package scripts\u3001\u8DEF\u7531\u3001\u6D4B\u8BD5\u3001\u6E90\u7801\u7ED3\u6784\u548C\u73B0\u6709\u7EA6\u5B9A\u540E\uFF0C\u628A AGENTS.md \u4E2D**\u5176\u4F59** \`[NEEDS LLM INPUT]\` \u6216 \`[NEED LLM INPUT]\` \u5360\u4F4D\u7B26\u66FF\u6362\u4E3A\u5177\u4F53\u3001\u7B80\u6D01\u3001\u9879\u76EE\u76F8\u5173\u7684\u5185\u5BB9\u3002\u4FDD\u7559 FET \u6258\u7BA1\u6807\u8BB0\uFF0C\u4E0D\u8981\u4FEE\u6539\u4E1A\u52A1\u4EE3\u7801\u3002
 `;
   }
   if (command === "graph-setup") {
@@ -4421,14 +5339,14 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists4(join17(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
       }))
@@ -4438,7 +5356,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join17(projectRoot, file.path);
+      const target = join21(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -4461,7 +5379,7 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join17(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}`));
@@ -4477,14 +5395,14 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile17(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists4(path) {
+async function exists6(path) {
   try {
-    await stat7(path);
+    await stat10(path);
     return true;
   } catch {
     return false;
@@ -4496,45 +5414,45 @@ import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 
 // src/openspec/inspector.ts
-import { readdir as readdir2, stat as stat8 } from "fs/promises";
-import { join as join18 } from "path";
+import { readdir as readdir4, stat as stat11 } from "fs/promises";
+import { join as join22 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join18(projectRoot, "openspec");
-  const changesPath = join18(openspecPath, "changes");
-  const legacyArchivePath = join18(openspecPath, "archive");
-  const changesArchivePath = join18(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 exists5(openspecPath),
+    exists: await exists7(openspecPath),
     changes: await listDirectories(changesPath, { exclude: ["archive"] }),
     archived: [.../* @__PURE__ */ new Set([...await listDirectories(legacyArchivePath), ...await listDirectories(changesArchivePath)])]
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join18(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join18(changePath, "tasks.md");
-  const specsPath = join18(changePath, "specs");
+  const changePath = join22(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join22(changePath, "tasks.md");
+  const specsPath = join22(changePath, "specs");
   return {
     changeId,
-    exists: await exists5(changePath),
-    hasProposal: await exists5(join18(changePath, "proposal.md")),
-    hasTasks: await exists5(tasksPath),
-    hasSpecs: await exists5(specsPath),
+    exists: await exists7(changePath),
+    hasProposal: await exists7(join22(changePath, "proposal.md")),
+    hasTasks: await exists7(tasksPath),
+    hasSpecs: await exists7(specsPath),
     tasksPath,
     changePath
   };
 }
 async function listDirectories(path, options = {}) {
   try {
-    const entries = await readdir2(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 {
     return [];
   }
 }
-async function exists5(path) {
+async function exists7(path) {
   try {
-    await stat8(path);
+    await stat11(path);
     return true;
   } catch {
     return false;
@@ -4716,146 +5634,15 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/scanner/package.ts
-import { readFile as readFile15, stat as stat9 } from "fs/promises";
-import { join as join19 } from "path";
-import { parse as parse2 } from "yaml";
-async function readPackageJson(projectRoot) {
-  try {
-    return JSON.parse(await readFile15(join19(projectRoot, "package.json"), "utf8"));
-  } catch {
-    return null;
-  }
-}
-async function detectPackageManager(projectRoot, pkg) {
-  const warnings = [];
-  if (pkg?.packageManager) {
-    const declared = pkg.packageManager.split("@")[0] ?? "unknown";
-    const locks2 = await detectLockManagers(projectRoot);
-    const conflicting = locks2.filter((item) => item !== declared);
-    if (conflicting.length) {
-      warnings.push(`packageManager \u58F0\u660E\u4E3A ${declared}\uFF0C\u4F46\u540C\u65F6\u53D1\u73B0\u9501\u6587\u4EF6\uFF1A${conflicting.join(", ")}`);
-    }
-    return { manager: declared, confidence: "high", warnings };
-  }
-  const locks = await detectLockManagers(projectRoot);
-  if (locks.length > 1) {
-    warnings.push(`\u53D1\u73B0\u591A\u4E2A\u5305\u7BA1\u7406\u5668\u9501\u6587\u4EF6\uFF1A${locks.join(", ")}\uFF0C\u9ED8\u8BA4\u4F7F\u7528 ${locks[0]}`);
-    return { manager: locks[0] ?? "npm", confidence: "medium", warnings };
-  }
-  if (locks[0]) {
-    return { manager: locks[0], confidence: "high", warnings };
-  }
-  return { manager: "npm", confidence: "low", warnings };
-}
-function extractCommands(pkg, packageManager) {
-  const scripts = pkg?.scripts ?? {};
-  const result = {};
-  const scriptNames = ["dev", "build", "lint", "typecheck", "check", "test", "test:unit"];
-  for (const name of scriptNames) {
-    if (scripts[name]) {
-      const dimension = name === "check" ? "typecheck" : name === "test:unit" ? "test" : name;
-      if (result[dimension]) {
-        continue;
-      }
-      result[dimension] = {
-        command: scriptCommand(packageManager, name),
-        source: `package.json:scripts.${name}`,
-        required: name === "build"
-      };
-    }
-  }
-  return result;
-}
-function detectFramework(pkg) {
-  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  const candidates = [
-    ["next", ["next"]],
-    ["nuxt", ["nuxt"]],
-    ["vite", ["vite"]],
-    ["sveltekit", ["@sveltejs/kit"]],
-    ["angular", ["@angular/core", "@angular/cli"]],
-    ["react", ["react"]],
-    ["vue", ["vue"]],
-    ["svelte", ["svelte"]]
-  ];
-  for (const [candidate, packages] of candidates) {
-    if (packages.some((name) => deps[name])) {
-      return { name: candidate, confidence: "high", sources: ["package.json"] };
-    }
-  }
-  return { name: "unknown", confidence: "low", sources: [] };
-}
-async function detectLanguage(projectRoot, pkg) {
-  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  if (deps.typescript || await exists6(join19(projectRoot, "tsconfig.json"))) {
-    return "typescript";
-  }
-  return "javascript";
-}
-async function detectWorkspaces(projectRoot, pkg) {
-  const packageWorkspaces = normalizeWorkspaces(pkg?.workspaces).map((path) => ({
-    name: path,
-    path,
-    source: "package.json:workspaces"
-  }));
-  if (packageWorkspaces.length) {
-    return packageWorkspaces;
-  }
-  try {
-    const workspace = parse2(await readFile15(join19(projectRoot, "pnpm-workspace.yaml"), "utf8"));
-    return (workspace?.packages ?? []).map((path) => ({
-      name: path,
-      path,
-      source: "pnpm-workspace.yaml:packages"
-    }));
-  } catch {
-    return [];
-  }
-}
-async function detectLockManagers(projectRoot) {
-  const lockFiles = [
-    ["pnpm-lock.yaml", "pnpm"],
-    ["yarn.lock", "yarn"],
-    ["bun.lockb", "bun"],
-    ["bun.lock", "bun"],
-    ["package-lock.json", "npm"]
-  ];
-  const found = [];
-  for (const [file, manager] of lockFiles) {
-    if (await exists6(join19(projectRoot, file))) {
-      found.push(manager);
-    }
-  }
-  return found;
-}
-function normalizeWorkspaces(workspaces) {
-  if (Array.isArray(workspaces)) {
-    return workspaces;
-  }
-  return workspaces?.packages ?? [];
-}
-function scriptCommand(packageManager, name) {
-  return packageManager === "npm" ? `npm run ${name}` : `${packageManager} ${name}`;
-}
-async function exists6(path) {
-  try {
-    await stat9(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/scanner/routes.ts
-import { readdir as readdir3, stat as stat10 } from "fs/promises";
-import { join as join20, relative, 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 = join20(projectRoot, candidate);
-    if (!await exists7(root)) {
+    const root = join23(projectRoot, candidate);
+    if (!await exists8(root)) {
       continue;
     }
     for (const file of await listFiles(root)) {
@@ -4863,8 +5650,8 @@ async function scanRoutes(projectRoot) {
         continue;
       }
       routes.push({
-        path: inferRoutePath(relative(root, file)),
-        source: relative(projectRoot, file).split(sep).join("/"),
+        path: inferRoutePath(relative3(root, file)),
+        source: relative3(projectRoot, file).split(sep).join("/"),
         inferred: true,
         confidence: "medium"
       });
@@ -4879,10 +5666,10 @@ function inferRoutePath(relativePath) {
   return `/${withoutIndex}`.replace(/\/+/g, "/");
 }
 async function listFiles(root) {
-  const entries = await readdir3(root, { withFileTypes: true });
+  const entries = await readdir5(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join20(root, entry.name);
+    const path = join23(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -4891,9 +5678,9 @@ async function listFiles(root) {
   }
   return files;
 }
-async function exists7(path) {
+async function exists8(path) {
   try {
-    await stat10(path);
+    await stat12(path);
     return true;
   } catch {
     return false;
@@ -4908,10 +5695,14 @@ var ProjectScanner = class {
     const framework = detectFramework(pkg);
     const workspaces = await detectWorkspaces(projectRoot, pkg);
     const language = await detectLanguage(projectRoot, pkg);
+    const miniprogram = await detectMiniprogramProject(projectRoot);
     const warnings = [...packageManager.warnings];
     if (framework.name === "unknown") {
       warnings.push("\u672A\u80FD\u4ECE package.json \u8BC6\u522B\u4E3B\u8981\u6846\u67B6");
     }
+    if (miniprogram.supported) {
+      warnings.push(...miniprogram.warnings);
+    }
     return {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       scannerVersion: 1,
@@ -4928,7 +5719,8 @@ var ProjectScanner = class {
       routes: await scanRoutes(projectRoot),
       conventions: [],
       skippedFiles: [],
-      warnings
+      warnings,
+      miniprogram
     };
   }
 };
@@ -5045,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 readFile16, 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 join21 } 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();
@@ -5120,11 +5912,11 @@ function formatFetUpdateWarning(availability, language) {
 }
 function cachePath() {
   const home = process.env.FET_UPDATE_CHECK_CACHE_HOME?.trim() || homedir2();
-  return join21(home, ".fet", "update-check-cache.json");
+  return join24(home, ".fet", "update-check-cache.json");
 }
 async function readUpdateCheckCache() {
   try {
-    const raw = await readFile16(cachePath(), "utf8");
+    const raw = await readFile18(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
       return null;