@nick848/fet 1.1.4 → 1.1.6

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import {
 } from "../chunk-J5WB4KAL.js";
 
 // src/cli/index.ts
-import { createInterface as createInterface2 } from "readline/promises";
+import { createInterface as createInterface3 } from "readline/promises";
 import { Command } from "commander";
 
 // src/commands/doctor.ts
@@ -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 relative3 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
+  const graphPath = join5(projectRoot, relative3);
   try {
     const info = await stat2(graphPath);
     return {
-      graphPath: relative2,
+      graphPath: relative3,
       graphExists: true,
       lastIndexedAt: info.mtime.toISOString()
     };
   } catch {
     return {
-      graphPath: relative2,
+      graphPath: relative3,
       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.
@@ -1543,58 +2239,6 @@ fet verify --done --change ${changeId}
 `;
 }
 
-// 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*$/, "")}
-
-${block}
-`;
-}
-
-// 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();
-}
-
 // src/commands/update-context.ts
 async function updateContextCommand(ctx) {
   let contextResult = { warnings: [] };
@@ -1610,11 +2254,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 +2332,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 +2340,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 +2355,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,21 +2390,9 @@ 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 readOptional3(path) {
-  try {
-    return await readFile8(path, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function exists2(path) {
+async function exists4(path) {
   try {
-    await stat4(path);
+    await stat6(path);
     return true;
   } catch {
     return false;
@@ -1769,8 +2400,8 @@ async function exists2(path) {
 }
 
 // src/commands/proxy.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/state/project.ts
 import { execFile as execFile2 } from "child_process";
@@ -1799,8 +2430,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 readFile11 } from "fs/promises";
+import { join as join16 } from "path";
 
 // src/language.ts
 var DEFAULT_LANGUAGE = "zh-CN";
@@ -1918,7 +2549,7 @@ var StateStore = class {
   project;
   async readGlobal() {
     try {
-      const value = JSON.parse(await readFile9(this.globalPath(), "utf8"));
+      const value = JSON.parse(await readFile11(this.globalPath(), "utf8"));
       assertGlobalState(value);
       return value;
     } catch (error) {
@@ -1933,13 +2564,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join13(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir6(join16(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 readFile11(this.changePath(changeId), "utf8"));
       assertChangeState(value);
       return value;
     } catch (error) {
@@ -1954,15 +2585,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(join16(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 join16(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join13(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join16(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -1970,11 +2601,11 @@ function isNotFound(error) {
 }
 
 // src/state/tasks.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 async function readCompletedTaskIds(tasksPath) {
   let content;
   try {
-    content = await readFile10(tasksPath, "utf8");
+    content = await readFile12(tasksPath, "utf8");
   } catch {
     return [];
   }
@@ -2502,8 +3133,8 @@ async function createChangelogEntry(projectRoot, changeId) {
   };
 }
 async function appendChangelog(projectRoot, entry) {
-  const changelogPath = join14(projectRoot, "CHANGELOG.md");
-  const existing = await readOptional4(changelogPath);
+  const changelogPath = join17(projectRoot, "CHANGELOG.md");
+  const existing = await readOptional3(changelogPath);
   const legacyContentLabel = "\u66F4\u65B0\u5185\u5BB9";
   const block = `updateTime: ${entry.updateTime}
 changeRequirement:${entry.content}
@@ -2515,12 +3146,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 = join17(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional3(join17(changeRoot, "proposal.md"));
   if (proposal) {
     return summarizeMarkdown(proposal);
   }
-  const readme = await readOptional4(join14(changeRoot, "README.md"));
+  const readme = await readOptional3(join17(changeRoot, "README.md"));
   if (readme) {
     return summarizeMarkdown(readme);
   }
@@ -2530,9 +3161,9 @@ function summarizeMarkdown(content) {
   const normalized = content.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("<!--") && !line.startsWith("---")).join(" ");
   return normalized || "No change requirement found.";
 }
-async function readOptional4(path) {
+async function readOptional3(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch {
     return null;
   }
@@ -2679,60 +3310,16 @@ async function assertVerifiedChange(ctx, changeId) {
   }
 }
 
-// src/commands/update.ts
+// src/update/npm.ts
 import { spawn } from "child_process";
-var DEFAULT_PACKAGE_NAME = "@nick848/fet";
-async function updateCommand(ctx) {
-  const packageName = process.env.FET_UPDATE_PACKAGE_NAME ?? DEFAULT_PACKAGE_NAME;
-  const npmExecutable = process.env.FET_UPDATE_NPM_EXECUTABLE ?? defaultNpmExecutable();
-  const latestVersion = await resolveLatestVersion(packageName, npmExecutable);
-  const currentVersion = ctx.fetVersion;
-  if (compareVersions(currentVersion, latestVersion) >= 0) {
-    ctx.output.result({
-      ok: true,
-      command: "update",
-      summary: ctx.language === "en" ? `FET is already up to date (${currentVersion}).` : `FET \u5DF2\u662F\u6700\u65B0\u7248 (${currentVersion})\u3002`,
-      data: {
-        packageName,
-        currentVersion,
-        latestVersion,
-        updated: false
-      }
-    });
-    return;
-  }
-  if (!ctx.json) {
-    ctx.output.info(
-      ctx.language === "en" ? `Updating FET from ${currentVersion} to ${latestVersion}...` : `\u6B63\u5728\u5C06 FET \u4ECE ${currentVersion} \u5347\u7EA7\u5230 ${latestVersion}...`
-    );
-  }
-  const installArgs = ["install", "-g", `${packageName}@latest`];
-  const result = await runNpm(npmExecutable, installArgs, {
-    cwd: ctx.cwd,
-    stdio: ctx.json ? "pipe" : "inherit"
-  });
-  if (result.exitCode !== 0) {
-    throw new FetError({
-      code: "UPDATE_FAILED" /* UpdateFailed */,
-      message: ctx.language === "en" ? "FET update failed." : "FET \u5347\u7EA7\u5931\u8D25\u3002",
-      details: result,
-      suggestedCommand: `${npmExecutable} ${installArgs.join(" ")}`
-    });
-  }
-  ctx.output.result({
-    ok: true,
-    command: "update",
-    summary: ctx.language === "en" ? `FET updated from ${currentVersion} to ${latestVersion}.` : `FET \u5DF2\u4ECE ${currentVersion} \u5347\u7EA7\u5230 ${latestVersion}\u3002`,
-    data: {
-      packageName,
-      currentVersion,
-      latestVersion,
-      updated: true,
-      installCommand: `${npmExecutable} ${installArgs.join(" ")}`
-    }
-  });
+var DEFAULT_FET_PACKAGE_NAME = "@nick848/fet";
+function getFetPackageName(env = process.env) {
+  return env.FET_UPDATE_PACKAGE_NAME?.trim() || DEFAULT_FET_PACKAGE_NAME;
+}
+function getNpmExecutable(env = process.env) {
+  return env.FET_UPDATE_NPM_EXECUTABLE?.trim() || (process.platform === "win32" ? "npm.cmd" : "npm");
 }
-async function resolveLatestVersion(packageName, npmExecutable) {
+async function resolveLatestFetVersion(packageName = getFetPackageName(), npmExecutable = getNpmExecutable()) {
   const override = process.env.FET_UPDATE_LATEST_VERSION?.trim();
   if (override) {
     return override;
@@ -2759,6 +3346,32 @@ async function resolveLatestVersion(packageName, npmExecutable) {
   }
   return version;
 }
+async function performFetUpdate(currentVersion, latestVersion, options) {
+  const packageName = getFetPackageName();
+  const npmExecutable = getNpmExecutable();
+  const installArgs = ["install", "-g", `${packageName}@latest`];
+  if (!options.json) {
+    options.info(
+      options.language === "en" ? `Updating FET from ${currentVersion} to ${latestVersion}...` : `\u6B63\u5728\u5C06 FET \u4ECE ${currentVersion} \u5347\u7EA7\u5230 ${latestVersion}...`
+    );
+  }
+  const result = await runNpm(npmExecutable, installArgs, {
+    cwd: options.cwd,
+    stdio: options.json ? "pipe" : "inherit"
+  });
+  if (result.exitCode !== 0) {
+    throw new FetError({
+      code: "UPDATE_FAILED" /* UpdateFailed */,
+      message: options.language === "en" ? "FET update failed." : "FET \u5347\u7EA7\u5931\u8D25\u3002",
+      details: result,
+      suggestedCommand: `${npmExecutable} ${installArgs.join(" ")}`
+    });
+  }
+  return {
+    packageName,
+    installCommand: `${npmExecutable} ${installArgs.join(" ")}`
+  };
+}
 function parseNpmVersion(stdout) {
   const trimmed = stdout.trim();
   if (!trimmed) {
@@ -2805,9 +3418,6 @@ function runNpm(command, args, options) {
     });
   });
 }
-function defaultNpmExecutable() {
-  return process.platform === "win32" ? "npm.cmd" : "npm";
-}
 function compareVersions(left, right) {
   const leftVersion = parseVersion(left);
   const rightVersion = parseVersion(right);
@@ -2868,10 +3478,49 @@ function comparePrereleasePart(left, right) {
   return left.localeCompare(right);
 }
 
+// src/commands/update.ts
+async function updateCommand(ctx) {
+  const packageName = getFetPackageName();
+  const latestVersion = await resolveLatestFetVersion(packageName);
+  const currentVersion = ctx.fetVersion;
+  if (compareVersions(currentVersion, latestVersion) >= 0) {
+    ctx.output.result({
+      ok: true,
+      command: "update",
+      summary: ctx.language === "en" ? `FET is already up to date (${currentVersion}).` : `FET \u5DF2\u662F\u6700\u65B0\u7248 (${currentVersion})\u3002`,
+      data: {
+        packageName,
+        currentVersion,
+        latestVersion,
+        updated: false
+      }
+    });
+    return;
+  }
+  const install = await performFetUpdate(currentVersion, latestVersion, {
+    cwd: ctx.cwd,
+    json: ctx.json,
+    language: ctx.language,
+    info: (message) => ctx.output.info(message)
+  });
+  ctx.output.result({
+    ok: true,
+    command: "update",
+    summary: ctx.language === "en" ? `FET updated from ${currentVersion} to ${latestVersion}.` : `FET \u5DF2\u4ECE ${currentVersion} \u5347\u7EA7\u5230 ${latestVersion}\u3002`,
+    data: {
+      packageName,
+      currentVersion,
+      latestVersion,
+      updated: true,
+      installCommand: install.installCommand
+    }
+  });
+}
+
 // 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 readFile14, stat as stat7 } from "fs/promises";
+import { join as join18 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -2938,8 +3587,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 = join18(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join18(dir, "verify-instructions.md");
   await mkdir7(dir, { recursive: true });
   await atomicWrite(instructionsPath, renderVerifyInstructions(changeId, generatedAt));
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -2956,7 +3605,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 = join18(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");
@@ -2991,8 +3640,8 @@ async function assertChangeExists(ctx, changeId) {
 }
 async function readInstructions(path, changeId) {
   try {
-    await stat5(path);
-    const content = await readFile12(path, "utf8");
+    await stat7(path);
+    const content = await readFile14(path, "utf8");
     const fileChangeId = readFrontMatterValue(content, "changeId");
     if (fileChangeId !== changeId) {
       throw new FetError({
@@ -3130,9 +3779,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 readFile15, stat as stat8 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname8, join as join16 } from "path";
+import { dirname as dirname8, join as join19 } from "path";
 
 // src/adapters/commands.ts
 var FET_WORKFLOW_COMMANDS = [
@@ -3565,7 +4214,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 = {
@@ -3662,10 +4311,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
    \`\`\`
@@ -4172,7 +4822,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(join19(projectRoot, ".codex")) || await exists5(join19(projectRoot, "AGENTS.md")),
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
@@ -4238,9 +4888,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join16(resolveCodexHome(), file.path);
+    return join19(resolveCodexHome(), file.path);
   }
-  return join16(projectRoot, file.path);
+  return join19(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -4249,18 +4899,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 ?? join19(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile15(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists3(path) {
+async function exists5(path) {
   try {
-    await stat6(path);
+    await stat8(path);
     return true;
   } catch {
     return false;
@@ -4268,8 +4918,8 @@ 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 readFile16, stat as stat9 } from "fs/promises";
+import { dirname as dirname9, join as join20 } from "path";
 
 // src/adapters/cursor/templates.ts
 function cursorSkillFiles(language = DEFAULT_LANGUAGE) {
@@ -4334,7 +4984,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") {
@@ -4403,7 +5055,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists4(join17(projectRoot, ".cursor")),
+      detected: await exists6(join20(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -4420,7 +5072,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join17(projectRoot, file.path);
+      const target = join20(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -4443,7 +5095,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 = join20(projectRoot, file.path);
       const content = await readExisting2(target);
       const managed = Boolean(content?.includes("FET:MANAGED"));
       const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
@@ -4459,14 +5111,14 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile16(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists4(path) {
+async function exists6(path) {
   try {
-    await stat7(path);
+    await stat9(path);
     return true;
   } catch {
     return false;
@@ -4478,45 +5130,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 readdir3, stat as stat10 } from "fs/promises";
+import { join as join21 } 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 = join21(projectRoot, "openspec");
+  const changesPath = join21(openspecPath, "changes");
+  const legacyArchivePath = join21(openspecPath, "archive");
+  const changesArchivePath = join21(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 = join21(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join21(changePath, "tasks.md");
+  const specsPath = join21(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(join21(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 readdir3(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 stat10(path);
     return true;
   } catch {
     return false;
@@ -4698,146 +5350,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 readdir4, stat as stat11 } from "fs/promises";
+import { join as join22, relative as relative2, 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 = join22(projectRoot, candidate);
+    if (!await exists8(root)) {
       continue;
     }
     for (const file of await listFiles(root)) {
@@ -4845,8 +5366,8 @@ async function scanRoutes(projectRoot) {
         continue;
       }
       routes.push({
-        path: inferRoutePath(relative(root, file)),
-        source: relative(projectRoot, file).split(sep).join("/"),
+        path: inferRoutePath(relative2(root, file)),
+        source: relative2(projectRoot, file).split(sep).join("/"),
         inferred: true,
         confidence: "medium"
       });
@@ -4861,10 +5382,10 @@ function inferRoutePath(relativePath) {
   return `/${withoutIndex}`.replace(/\/+/g, "/");
 }
 async function listFiles(root) {
-  const entries = await readdir3(root, { withFileTypes: true });
+  const entries = await readdir4(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join20(root, entry.name);
+    const path = join22(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -4873,9 +5394,9 @@ async function listFiles(root) {
   }
   return files;
 }
-async function exists7(path) {
+async function exists8(path) {
   try {
-    await stat10(path);
+    await stat11(path);
     return true;
   } catch {
     return false;
@@ -4890,10 +5411,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,
@@ -4910,7 +5435,8 @@ var ProjectScanner = class {
       routes: await scanRoutes(projectRoot),
       conventions: [],
       skippedFiles: [],
-      warnings
+      warnings,
+      miniprogram
     };
   }
 };
@@ -5023,6 +5549,173 @@ async function createCommandContext(command, options) {
   };
 }
 
+// src/cli/update-check.ts
+import { createInterface as createInterface2 } from "readline/promises";
+
+// src/update/check.ts
+import { mkdir as mkdir10, readFile as readFile17, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname10, join as join23 } from "path";
+var DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
+function getFetUpdateCheckMode(env = process.env) {
+  const value = env.FET_UPDATE_CHECK?.trim().toLowerCase();
+  if (value === "off" || env.FET_SKIP_UPDATE_CHECK === "1") {
+    return "off";
+  }
+  if (value === "warn") {
+    return "warn";
+  }
+  if (value === "confirm") {
+    return "confirm";
+  }
+  return "confirm";
+}
+function shouldCheckFetUpdateForCommand(command) {
+  return command !== "update";
+}
+async function resolveFetUpdateAvailability(currentVersion) {
+  const packageName = getFetPackageName();
+  const cache = await readUpdateCheckCache();
+  const ttlMs = Number.parseInt(process.env.FET_UPDATE_CHECK_TTL_MS ?? "", 10);
+  const cacheTtlMs = Number.isFinite(ttlMs) && ttlMs > 0 ? ttlMs : DEFAULT_CACHE_TTL_MS;
+  let latestVersion = cache?.latestVersion;
+  const cacheFresh = cache?.checkedAt ? Date.now() - Date.parse(cache.checkedAt) < cacheTtlMs : false;
+  if (!latestVersion || !cacheFresh) {
+    try {
+      latestVersion = await resolveLatestFetVersion(packageName);
+      await writeUpdateCheckCache({
+        latestVersion,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        dismissedLatestVersion: cache?.dismissedLatestVersion
+      });
+    } catch {
+      if (cache?.latestVersion) {
+        latestVersion = cache.latestVersion;
+      } else {
+        return null;
+      }
+    }
+  }
+  if (compareVersions(currentVersion, latestVersion) >= 0) {
+    return null;
+  }
+  if (cache?.dismissedLatestVersion === latestVersion) {
+    return null;
+  }
+  return {
+    packageName,
+    currentVersion,
+    latestVersion
+  };
+}
+async function rememberDismissedFetUpdate(latestVersion) {
+  const cache = await readUpdateCheckCache() ?? {
+    latestVersion,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeUpdateCheckCache({
+    ...cache,
+    latestVersion,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dismissedLatestVersion: latestVersion
+  });
+}
+function formatFetUpdateWarning(availability, language) {
+  if (language === "en") {
+    return `A newer FET release is available (${availability.currentVersion} -> ${availability.latestVersion}). Run \`fet update\` or choose update when prompted.`;
+  }
+  return `\u68C0\u6D4B\u5230 FET \u6709\u65B0\u7248\u672C\uFF08\u5F53\u524D ${availability.currentVersion}\uFF0C\u6700\u65B0 ${availability.latestVersion}\uFF09\u3002\u53EF\u8FD0\u884C \`fet update\`\uFF0C\u6216\u5728\u63D0\u793A\u65F6\u9009\u62E9\u5347\u7EA7\u3002`;
+}
+function cachePath() {
+  const home = process.env.FET_UPDATE_CHECK_CACHE_HOME?.trim() || homedir2();
+  return join23(home, ".fet", "update-check-cache.json");
+}
+async function readUpdateCheckCache() {
+  try {
+    const raw = await readFile17(cachePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
+      return null;
+    }
+    return {
+      latestVersion: parsed.latestVersion,
+      checkedAt: parsed.checkedAt,
+      dismissedLatestVersion: typeof parsed.dismissedLatestVersion === "string" ? parsed.dismissedLatestVersion : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeUpdateCheckCache(cache) {
+  const path = cachePath();
+  await mkdir10(dirname10(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+}
+
+// src/cli/update-check.ts
+async function handleFetUpdateCheck(ctx) {
+  if (!shouldCheckFetUpdateForCommand(ctx.command)) {
+    return;
+  }
+  const mode = getFetUpdateCheckMode();
+  if (mode === "off") {
+    return;
+  }
+  const availability = await resolveFetUpdateAvailability(ctx.fetVersion);
+  if (!availability) {
+    return;
+  }
+  const warning = formatFetUpdateWarning(availability, ctx.language);
+  ctx.output.warn(warning);
+  const forceConfirm = process.env.FET_UPDATE_CHECK_FORCE_CONFIRM === "1";
+  const interactive = mode === "confirm" && !ctx.json && !ctx.yes && (forceConfirm || process.stdin.isTTY && process.stderr.isTTY);
+  if (!interactive) {
+    return;
+  }
+  const choice = await promptFetUpdateChoice(availability, ctx.language);
+  if (choice === "skip") {
+    await rememberDismissedFetUpdate(availability.latestVersion);
+    return;
+  }
+  if (choice === "cancel") {
+    throw new FetError({
+      code: "USER_CANCELLED" /* UserCancelled */,
+      message: ctx.language === "en" ? "Command cancelled before FET update." : "\u547D\u4EE4\u5DF2\u53D6\u6D88\uFF0C\u672A\u6267\u884C FET \u5347\u7EA7\u3002",
+      details: availability,
+      suggestedCommand: ctx.language === "en" ? `fet update` : "fet update"
+    });
+  }
+  await performFetUpdate(availability.currentVersion, availability.latestVersion, {
+    cwd: ctx.cwd,
+    json: ctx.json,
+    language: ctx.language,
+    info: (message) => ctx.output.info(message)
+  });
+  throw new FetError({
+    code: "USER_CANCELLED" /* UserCancelled */,
+    message: ctx.language === "en" ? `FET updated to ${availability.latestVersion}. Rerun this command to use the new version.` : `FET \u5DF2\u5347\u7EA7\u5230 ${availability.latestVersion}\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C\u5F53\u524D\u547D\u4EE4\u4EE5\u4F7F\u7528\u65B0\u7248\u672C\u3002`,
+    details: availability,
+    suggestedCommand: `fet ${ctx.command}`
+  });
+}
+async function promptFetUpdateChoice(availability, language) {
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  try {
+    const question = language === "en" ? `Update FET now (${availability.currentVersion} -> ${availability.latestVersion})? [U]pdate / [S]kip / [C]ancel [s]: ` : `\u662F\u5426\u73B0\u5728\u5347\u7EA7 FET\uFF08${availability.currentVersion} -> ${availability.latestVersion}\uFF09\uFF1F[U]\u5347\u7EA7 / [S]\u8DF3\u8FC7 / [C]\u53D6\u6D88 [s]: `;
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    if (answer === "u" || answer === "update" || answer === "\u5347\u7EA7") {
+      return "update";
+    }
+    if (answer === "c" || answer === "cancel" || answer === "\u53D6\u6D88") {
+      return "cancel";
+    }
+    return "skip";
+  } finally {
+    rl.close();
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("fet").description("\u56F4\u7ED5 OpenSpec \u7684\u524D\u7AEF\u5F00\u53D1\u5DE5\u4F5C\u6D41\u7F16\u6392\u5DE5\u5177\u3002").enablePositionalOptions().version(FET_VERSION).option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--lang <language>", "\u6307\u5B9A FET \u4EA4\u4E92\u4FE1\u606F\u548C\u751F\u6210\u4EA7\u7269\u8BED\u8A00\uFF0C\u9ED8\u8BA4 zh-CN").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
@@ -5066,6 +5759,7 @@ function wrap(command, handler) {
     const opts = isCommandLike(maybeCommand) ? { ...maybeCommand.parent?.opts(), ...maybeCommand.opts() } : program.opts();
     const ctx = await createCommandContext(command, { ...opts, ...extractGlobalOptions(args) });
     try {
+      await handleFetUpdateCheck(ctx);
       await handleModelPolicyRecommendation(ctx);
       await warnIfContextPlaceholdersRemain(ctx);
       await handler(ctx, ...args);
@@ -5087,7 +5781,7 @@ async function handleModelPolicyRecommendation(ctx) {
   if (policyMode !== "confirm" || ctx.yes || ctx.json || !process.stdin.isTTY || !process.stderr.isTTY) {
     return;
   }
-  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  const rl = createInterface3({ input: process.stdin, output: process.stderr });
   try {
     const question = ctx.language === "en" ? "Continue anyway? [y/N] " : "\u4ECD\u7136\u7EE7\u7EED\uFF1F[y/N] ";
     const answer = (await rl.question(question)).trim().toLowerCase();