@nick848/fet 1.1.9 → 1.1.10

package/dist/cli/index.js

@@ -188,18 +188,18 @@ function toGitNexusState(detection, previous) {
   };
 }
 async function inspectGitNexusGraph(projectRoot, env = process.env) {
-  const relative5 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
-  const graphPath = join5(projectRoot, relative5);
+  const relative6 = env.FET_GITNEXUS_GRAPH_PATH?.trim() || DEFAULT_GRAPH_PATH;
+  const graphPath = join5(projectRoot, relative6);
   try {
     const info = await stat2(graphPath);
     return {
-      graphPath: relative5,
+      graphPath: relative6,
       graphExists: true,
       lastIndexedAt: info.mtime.toISOString()
     };
   } catch {
     return {
-      graphPath: relative5,
+      graphPath: relative6,
       graphExists: false,
       lastIndexedAt: null
     };
@@ -2085,6 +2085,11 @@ function renderFetConfig(scan, language = "zh-CN") {
       uiDisplayContract: {
         enabled: true
       },
+      tdd: {
+        enabled: true,
+        mode: "require_before_apply",
+        whenNoTestScript: "block"
+      },
       specLanguage: {
         style: "layered_bilingual",
         canonical: "en",
@@ -2250,6 +2255,135 @@ fet verify --done --change ${changeId}
 `;
 }
 
+// src/tdd/paths.ts
+function tddFetDirRelative(changeId) {
+  return `openspec/changes/${changeId}/.fet`;
+}
+function tddManifestRelativePath(changeId) {
+  return `${tddFetDirRelative(changeId)}/tdd-manifest.yaml`;
+}
+function tddSpecRelativePath(changeId) {
+  return `${tddFetDirRelative(changeId)}/tdd-spec.md`;
+}
+function tddInstructionsRelativePath(changeId) {
+  return `${tddFetDirRelative(changeId)}/tdd-instructions.md`;
+}
+function tddResultsRelativePath(changeId) {
+  return `${tddFetDirRelative(changeId)}/tdd-results.json`;
+}
+
+// src/templates/tdd.ts
+function renderTddInstructions(changeId, manifest, language) {
+  const manifestPath2 = tddManifestRelativePath(changeId);
+  const specPath = tddSpecRelativePath(changeId);
+  const caseList = manifest.cases.map((item) => `- \`${item.id}\`: ${item.title} \u2192 \`${item.testFile}\` (${item.testIds.join(", ")})`).join("\n");
+  if (language === "en") {
+    return `---
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+changeId: ${changeId}
+purpose: tdd-instructions
+generatedAt: ${manifest.generatedAt}
+---
+
+# TDD instructions (this change)
+
+Create or update unit tests **before** marking implementation tasks done in \`tasks.md\`.
+
+## Sources
+${manifest.sources.map((s) => `- ${s}`).join("\n")}
+
+## Cases (from ${manifestPath2})
+${caseList}
+
+## Rules
+1. Each case must map to a real test file under the repo test tree.
+2. Tests should fail until implementation lands (red \u2192 green).
+3. Do not edit \`${manifestPath2}\` by hand unless fixing IDs; re-run \`fet tdd --change ${changeId}\` after planning changes.
+4. When tests exist, run \`fet test --change ${changeId}\` before \`fet verify\`.
+
+Human-readable matrix: \`${specPath}\`
+`;
+  }
+  return `---
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+changeId: ${changeId}
+purpose: tdd-instructions
+generatedAt: ${manifest.generatedAt}
+---
+
+# TDD \u6307\u4EE4\uFF08\u672C change\uFF09
+
+\u5728\u5C06 \`tasks.md\` \u4E2D\u7684\u4EFB\u52A1\u6807\u4E3A\u5B8C\u6210\u4E4B\u524D\uFF0C\u5148\u521B\u5EFA\u6216\u66F4\u65B0\u5355\u5143\u6D4B\u8BD5\u3002
+
+## \u6765\u6E90
+${manifest.sources.map((s) => `- ${s}`).join("\n")}
+
+## \u7528\u4F8B\uFF08\u89C1 ${manifestPath2}\uFF09
+${caseList}
+
+## \u89C4\u5219
+1. \u6BCF\u4E2A\u7528\u4F8B\u5FC5\u987B\u5BF9\u5E94\u4ED3\u5E93\u5185\u771F\u5B9E\u6D4B\u8BD5\u6587\u4EF6\u3002
+2. \u5B9E\u73B0\u843D\u5730\u524D\u6D4B\u8BD5\u5E94\u5904\u4E8E\u5931\u8D25\uFF08\u7EA2\uFF09\u72B6\u6001\uFF0C\u843D\u5730\u540E\u5E94\u53D8\u7EFF\u3002
+3. \u9664\u975E\u4FEE\u6B63 ID\uFF0C\u4E0D\u8981\u624B\u6539 \`${manifestPath2}\`\uFF1B\u89C4\u5212\u53D8\u66F4\u540E\u8BF7\u91CD\u65B0\u6267\u884C \`fet tdd --change ${changeId}\`\u3002
+4. \u6D4B\u8BD5\u5C31\u7EEA\u540E\u5148 \`fet test --change ${changeId}\`\uFF0C\u518D \`fet verify\`\u3002
+
+\u53EF\u8BFB\u77E9\u9635\u89C1 \`${specPath}\`
+`;
+}
+function renderTddSpec(changeId, manifest, language) {
+  const rows = manifest.cases.map((item) => renderSpecRow(item, language)).join("\n");
+  if (language === "en") {
+    return `---
+schemaVersion: 1
+changeId: ${changeId}
+generatedAt: ${manifest.generatedAt}
+planningFingerprint: ${manifest.planningFingerprint}
+---
+
+# TDD case matrix
+
+| ID | Scenario | Spec reference | Test file | Required |
+|----|----------|----------------|-----------|----------|
+${rows}
+`;
+  }
+  return `---
+schemaVersion: 1
+changeId: ${changeId}
+generatedAt: ${manifest.generatedAt}
+planningFingerprint: ${manifest.planningFingerprint}
+---
+
+# TDD \u7528\u4F8B\u77E9\u9635
+
+| ID | \u573A\u666F | Spec \u5F15\u7528 | \u6D4B\u8BD5\u6587\u4EF6 | \u5FC5\u9700 |
+|----|------|-----------|----------|------|
+${rows}
+`;
+}
+function renderSpecRow(item, language) {
+  const required = language === "en" ? item.required ? "yes" : "no" : item.required ? "\u662F" : "\u5426";
+  return `| ${item.id} | ${escapeTable(item.title)} | ${escapeTable(item.specRef)} | \`${item.testFile}\` | ${required} |`;
+}
+function escapeTable(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function renderTddApplyNextSteps(changeId, language) {
+  const manifestPath2 = tddManifestRelativePath(changeId);
+  if (language === "en") {
+    return [
+      `Read ${manifestPath2} and tdd-instructions.md; implement code until fet test passes for this change.`,
+      `Run fet test --change ${changeId} before fet verify.`
+    ];
+  }
+  return [
+    `\u9605\u8BFB ${manifestPath2} \u4E0E tdd-instructions.md\uFF1B\u5B9E\u73B0\u4EE3\u7801\u76F4\u81F3\u672C change \u7684 fet test \u901A\u8FC7\u3002`,
+    `\u5728 fet verify \u4E4B\u524D\u5148\u6267\u884C fet test --change ${changeId}\u3002`
+  ];
+}
+
 // src/templates/figma-guard.ts
 var FIGMA_URL_PATTERN = /https?:\/\/(?:www\.)?figma\.com\/(?:file|design|proto)\/[^\s)\]"'<>]+/gi;
 function figmaStopHandoffRelativePath(changeId) {
@@ -2889,8 +3023,8 @@ async function exists4(path) {
 }
 
 // src/commands/proxy.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join22 } from "path";
 
 // src/figma-guard.ts
 import { readdir as readdir3, readFile as readFile10, stat as stat7 } from "fs/promises";
@@ -3339,6 +3473,259 @@ async function readOptional4(path) {
   }
 }
 
+// src/commands/change-id.ts
+function toKebabId(value) {
+  return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function msg(language, zh, en) {
+  return language === "en" ? en : zh;
+}
+async function resolveChangeId(ctx) {
+  if (ctx.changeId) {
+    return ctx.changeId;
+  }
+  const global = await ctx.stateStore.getOrCreateGlobal();
+  if (global.activeChangeId) {
+    return global.activeChangeId;
+  }
+  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  if (inspection.changes.length === 1 && inspection.changes[0]) {
+    return inspection.changes[0];
+  }
+  throw new FetError({
+    code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+    message: msg(ctx.language, "\u65E0\u6CD5\u786E\u5B9A\u76EE\u6807 change", "Cannot determine which change to use"),
+    details: { openChangeIds: inspection.changes },
+    suggestedCommand: "fet <command> --change <change-id>"
+  });
+}
+async function assertChangeExists(ctx, changeId) {
+  const inspection = await ctx.openSpec.inspectChange(ctx.projectRoot, changeId);
+  if (!inspection.exists) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: msg(ctx.language, "\u6307\u5B9A\u7684 change \u4E0D\u5B58\u5728", "The specified change does not exist"),
+      details: { changeId },
+      suggestedCommand: `fet doctor`
+    });
+  }
+}
+
+// src/tdd/config.ts
+import { readFile as readFile12 } from "fs/promises";
+import { join as join18 } from "path";
+import { parseDocument as parseDocument4 } from "yaml";
+var DEFAULT_CONFIG3 = {
+  enabled: true,
+  mode: "require_before_apply",
+  whenNoTestScript: "block"
+};
+async function loadTddConfig(projectRoot) {
+  try {
+    const raw = await readFile12(join18(projectRoot, "openspec", "config.yaml"), "utf8");
+    const doc = parseDocument4(raw);
+    const fetNode = doc.get("fet", true);
+    const node = fetNode?.get?.("tdd");
+    if (!node || typeof node.get !== "function") {
+      return DEFAULT_CONFIG3;
+    }
+    const enabled = node.get("enabled");
+    const modeRaw = node.get("mode");
+    const whenNoTestScriptRaw = node.get("whenNoTestScript");
+    return {
+      enabled: enabled === void 0 ? true : Boolean(enabled),
+      mode: parseGateMode(modeRaw),
+      whenNoTestScript: parseWhenNoTestScript(whenNoTestScriptRaw)
+    };
+  } catch {
+    return DEFAULT_CONFIG3;
+  }
+}
+function parseGateMode(value) {
+  if (value === "off" || value === "optional" || value === "require_before_apply") {
+    return value;
+  }
+  return DEFAULT_CONFIG3.mode;
+}
+function parseWhenNoTestScript(value) {
+  if (value === "warn" || value === "skip") {
+    return value;
+  }
+  return DEFAULT_CONFIG3.whenNoTestScript;
+}
+function isTddRequired(config) {
+  return config.enabled && config.mode === "require_before_apply";
+}
+
+// src/tdd/fingerprint.ts
+import { createHash } from "crypto";
+import { readdir as readdir5, readFile as readFile13, stat as stat9 } from "fs/promises";
+import { join as join19, relative as relative4 } from "path";
+async function collectPlanningSources(projectRoot, changeId) {
+  const changeRoot = join19(projectRoot, "openspec", "changes", changeId);
+  const sources = [];
+  const rootFiles = ["proposal.md", "tasks.md", "design.md"];
+  for (const name of rootFiles) {
+    const path = join19(changeRoot, name);
+    if (await exists5(path)) {
+      sources.push(relative4(projectRoot, path).replace(/\\/g, "/"));
+    }
+  }
+  const specsDir = join19(changeRoot, "specs");
+  if (await exists5(specsDir)) {
+    for (const file of await walkFiles(specsDir)) {
+      if (file.endsWith(".md")) {
+        sources.push(relative4(projectRoot, file).replace(/\\/g, "/"));
+      }
+    }
+  }
+  return sources.sort();
+}
+async function computePlanningFingerprint(projectRoot, changeId) {
+  const sources = await collectPlanningSources(projectRoot, changeId);
+  const hash = createHash("sha256");
+  for (const source of sources) {
+    const content = await readFile13(join19(projectRoot, source), "utf8");
+    hash.update(source);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function walkFiles(dir) {
+  const entries = await readdir5(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join19(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(path));
+    } else if (entry.isFile()) {
+      files.push(path);
+    }
+  }
+  return files;
+}
+async function exists5(path) {
+  try {
+    await stat9(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tdd/manifest.ts
+import { mkdir as mkdir6, readFile as readFile14, stat as stat10 } from "fs/promises";
+import { dirname as dirname8, join as join20 } from "path";
+import { parse as parse4, stringify as stringify3 } from "yaml";
+function tddManifestPath(projectRoot, changeId) {
+  return join20(projectRoot, tddManifestRelativePath(changeId));
+}
+async function readTddManifest(projectRoot, changeId) {
+  const path = tddManifestPath(projectRoot, changeId);
+  try {
+    await stat10(path);
+  } catch {
+    return null;
+  }
+  const doc = parse4(await readFile14(path, "utf8"));
+  if (!doc || doc.schemaVersion !== 1 || doc.changeId !== changeId) {
+    return null;
+  }
+  return doc;
+}
+async function writeTddManifest(projectRoot, manifest) {
+  const relative6 = tddManifestRelativePath(manifest.changeId);
+  const path = join20(projectRoot, relative6);
+  await mkdir6(dirname8(path), { recursive: true });
+  await atomicWrite(path, stringify3(manifest));
+  return relative6;
+}
+async function writeTddResults(projectRoot, results) {
+  const relative6 = tddResultsRelativePath(results.changeId);
+  const path = join20(projectRoot, relative6);
+  await mkdir6(dirname8(path), { recursive: true });
+  await atomicWrite(path, `${JSON.stringify(results, null, 2)}
+`);
+  return relative6;
+}
+function createTddManifest(input) {
+  return {
+    schemaVersion: 1,
+    changeId: input.changeId,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fetVersion: FET_VERSION,
+    planningFingerprint: input.planningFingerprint,
+    sources: input.sources,
+    cases: input.cases,
+    run: {
+      mode: input.cases.length ? "manifest" : "workspace",
+      fallbackCommand: input.testCommand
+    }
+  };
+}
+
+// src/tdd/gates.ts
+async function assertTddReady(ctx, changeId) {
+  const config = await loadTddConfig(ctx.projectRoot);
+  if (!isTddRequired(config)) {
+    return;
+  }
+  const manifest = await readTddManifest(ctx.projectRoot, changeId);
+  if (!manifest) {
+    throw new FetError({
+      code: "STATE_CORRUPTED" /* StateCorrupted */,
+      message: msg(ctx.language, "\u7F3A\u5C11 TDD \u4EA7\u7269\uFF0C\u65E0\u6CD5\u8FDB\u5165 apply\u3002", "TDD artifacts are missing; cannot run apply."),
+      details: { changeId, expected: tddManifestRelativePath(changeId) },
+      suggestedCommand: `fet tdd --change ${changeId}`,
+      recoverable: true
+    });
+  }
+  const fingerprint2 = await computePlanningFingerprint(ctx.projectRoot, changeId);
+  if (manifest.planningFingerprint !== fingerprint2) {
+    throw new FetError({
+      code: "STATE_CORRUPTED" /* StateCorrupted */,
+      message: msg(
+        ctx.language,
+        "\u89C4\u5212\u4EA7\u7269\u5DF2\u53D8\u66F4\uFF0CTDD \u6E05\u5355\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u751F\u6210\u3002",
+        "Planning artifacts changed; TDD manifest is stale. Regenerate it."
+      ),
+      details: { changeId, manifestFingerprint: manifest.planningFingerprint, currentFingerprint: fingerprint2 },
+      suggestedCommand: `fet tdd --change ${changeId}`,
+      recoverable: true
+    });
+  }
+}
+async function assertTestPassed(ctx, changeId) {
+  const config = await loadTddConfig(ctx.projectRoot);
+  if (!config.enabled || config.mode === "off") {
+    return;
+  }
+  const change = await ctx.stateStore.readChange(changeId);
+  const testRun = change?.testRun;
+  if (testRun?.status === "skipped") {
+    return;
+  }
+  if (testRun?.status === "passed" && await fingerprintMatches(ctx, changeId, testRun)) {
+    return;
+  }
+  throw new FetError({
+    code: "STATE_CORRUPTED" /* StateCorrupted */,
+    message: msg(ctx.language, "\u672C change \u5C1A\u672A\u901A\u8FC7 fet test\u3002", "This change has not passed fet test yet."),
+    details: { changeId, testRun: testRun ?? null },
+    suggestedCommand: `fet test --change ${changeId}`,
+    recoverable: true
+  });
+}
+async function fingerprintMatches(ctx, changeId, testRun) {
+  const current = await computePlanningFingerprint(ctx.projectRoot, changeId);
+  return testRun.planningFingerprint === current;
+}
+function invalidateTestRun(state) {
+  state.testRun = null;
+}
+
 // src/state/project.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3366,8 +3753,8 @@ async function git(cwd, args) {
 }
 
 // src/state/store.ts
-import { mkdir as mkdir6, readFile as readFile12 } from "fs/promises";
-import { join as join18 } from "path";
+import { mkdir as mkdir7, readFile as readFile15 } from "fs/promises";
+import { join as join21 } from "path";
 
 // src/language.ts
 var DEFAULT_LANGUAGE = "zh-CN";
@@ -3429,6 +3816,8 @@ function createChangeState(fetVersion, changeId, phase) {
       lastSyncedAt: null
     },
     manualVerify: null,
+    tdd: null,
+    testRun: null,
     lastOpenSpecCommand: null,
     warnings: []
   };
@@ -3485,7 +3874,7 @@ var StateStore = class {
   project;
   async readGlobal() {
     try {
-      const value = JSON.parse(await readFile12(this.globalPath(), "utf8"));
+      const value = JSON.parse(await readFile15(this.globalPath(), "utf8"));
       assertGlobalState(value);
       return value;
     } catch (error) {
@@ -3500,13 +3889,13 @@ var StateStore = class {
   }
   async writeGlobal(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join18(this.projectRoot, "openspec"), { recursive: true });
+    await mkdir7(join21(this.projectRoot, "openspec"), { recursive: true });
     await atomicWrite(this.globalPath(), `${JSON.stringify(state, null, 2)}
 `);
   }
   async readChange(changeId) {
     try {
-      const value = JSON.parse(await readFile12(this.changePath(changeId), "utf8"));
+      const value = JSON.parse(await readFile15(this.changePath(changeId), "utf8"));
       assertChangeState(value);
       return value;
     } catch (error) {
@@ -3521,15 +3910,15 @@ var StateStore = class {
   }
   async writeChange(state) {
     state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await mkdir6(join18(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
+    await mkdir7(join21(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
     await atomicWrite(this.changePath(state.changeId), `${JSON.stringify(state, null, 2)}
 `);
   }
   globalPath() {
-    return join18(this.projectRoot, "openspec", "fet-state.json");
+    return join21(this.projectRoot, "openspec", "fet-state.json");
   }
   changePath(changeId) {
-    return join18(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+    return join21(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
   }
 };
 function isNotFound(error) {
@@ -3537,11 +3926,11 @@ function isNotFound(error) {
 }
 
 // src/state/tasks.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 async function readCompletedTaskIds(tasksPath) {
   let content;
   try {
-    content = await readFile13(tasksPath, "utf8");
+    content = await readFile16(tasksPath, "utf8");
   } catch {
     return [];
   }
@@ -3675,6 +4064,7 @@ async function applyWorkflowCommand(ctx, args) {
   await withProjectLock(ctx.projectRoot, { command: "apply", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
     await assertOpenSpecCommandSupported(ctx, "status", "apply");
     await assertOpenSpecCommandSupported(ctx, "instructions", "apply");
+    await assertTddReady(ctx, changeId);
     runState.graphContext = await buildWorkflowGraphContext(ctx, {
       command: "apply",
       args: ["tasks", "--change", changeId],
@@ -3706,6 +4096,7 @@ async function applyWorkflowCommand(ctx, args) {
     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.",
+      ...renderTddApplyNextSteps(changeId, ctx.language),
       `Run fet verify --change ${changeId}`
     ];
     if (uiContract) {
@@ -3850,7 +4241,7 @@ async function onboardWorkflowCommand(ctx) {
     summary: "fet onboard loaded local FET/OpenSpec workflow context.",
     nextSteps: [
       inspection.changes.length ? `Open changes: ${inspection.changes.join(", ")}` : "No open changes found. Run fet propose <change-id-or-description> to start one.",
-      "Use fet continue to prepare planning artifacts, fet apply for implementation instructions, fet verify before archive."
+      "Use fet continue to prepare planning artifacts, fet tdd then fet apply for implementation, fet test then fet verify before archive."
     ],
     data: { activeChangeId: state.activeChangeId, openChangeIds: inspection.changes, archivedChangeIds: inspection.archived }
   });
@@ -3895,7 +4286,7 @@ async function artifactWorkflowCommand(ctx, command, args) {
       `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`
+      status.isComplete ? `Run fet tdd --change ${changeId}, then fet apply --change ${changeId}` : `Run fet continue --change ${changeId} when ready for the next artifact`
     ];
     if (uiContract) {
       planningNextSteps.unshift(
@@ -3937,7 +4328,7 @@ async function ensureProposedChange(ctx, args) {
     });
   }
   const input = args.join(" ").trim();
-  const changeId = isKebabId(input) ? input : toKebabId(input);
+  const changeId = isKebabId(input) ? input : toKebabId2(input);
   if (!changeId) {
     throw new FetError({
       code: "INVALID_ARGUMENTS" /* InvalidArguments */,
@@ -4087,7 +4478,7 @@ function resolveOutputPath(status, artifactId) {
 function isKebabId(value) {
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 }
-function toKebabId(value) {
+function toKebabId2(value) {
   return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 function parseOpenSpecJson(stdout) {
@@ -4124,7 +4515,7 @@ async function createChangelogEntry(projectRoot, changeId) {
   };
 }
 async function appendChangelog(projectRoot, entry) {
-  const changelogPath = join19(projectRoot, "CHANGELOG.md");
+  const changelogPath = join22(projectRoot, "CHANGELOG.md");
   const existing = await readOptional5(changelogPath);
   const legacyContentLabel = "\u66F4\u65B0\u5185\u5BB9";
   const block = `updateTime: ${entry.updateTime}
@@ -4137,12 +4528,12 @@ ${block}` : block;
   await atomicWrite(changelogPath, next);
 }
 async function readChangeRequirement(projectRoot, changeId) {
-  const changeRoot = join19(projectRoot, "openspec", "changes", changeId);
-  const proposal = await readOptional5(join19(changeRoot, "proposal.md"));
+  const changeRoot = join22(projectRoot, "openspec", "changes", changeId);
+  const proposal = await readOptional5(join22(changeRoot, "proposal.md"));
   if (proposal) {
     return summarizeMarkdown(proposal);
   }
-  const readme = await readOptional5(join19(changeRoot, "README.md"));
+  const readme = await readOptional5(join22(changeRoot, "README.md"));
   if (readme) {
     return summarizeMarkdown(readme);
   }
@@ -4154,7 +4545,7 @@ function summarizeMarkdown(content) {
 }
 async function readOptional5(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile17(path, "utf8");
   } catch {
     return null;
   }
@@ -4508,13 +4899,402 @@ async function updateCommand(ctx) {
   });
 }
 
-// src/commands/verify.ts
-import { createHash } from "crypto";
-import { mkdir as mkdir7, readFile as readFile15, stat as stat9 } from "fs/promises";
-import { join as join20 } from "path";
-function msg(language, zh, en) {
-  return language === "en" ? en : zh;
+// src/commands/tdd.ts
+import { mkdir as mkdir8 } from "fs/promises";
+import { join as join24 } from "path";
+
+// src/tdd/extract-cases.ts
+import { readFile as readFile18 } from "fs/promises";
+import { join as join23 } from "path";
+async function extractCasesFromChange(projectRoot, changeId, sources) {
+  const cases = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const content = await readFile18(join23(projectRoot, source), "utf8");
+    if (source.endsWith("tasks.md")) {
+      for (const item of extractTaskCases(content, changeId)) {
+        if (!seen.has(item.id)) {
+          seen.add(item.id);
+          cases.push({ ...item, specRef: `${source} \u2014 ${item.specRef}` });
+        }
+      }
+    }
+    if (source.includes("/specs/") && source.endsWith(".md")) {
+      for (const item of extractScenarioCases(content, changeId, source)) {
+        if (!seen.has(item.id)) {
+          seen.add(item.id);
+          cases.push(item);
+        }
+      }
+    }
+  }
+  if (!cases.length) {
+    cases.push({
+      id: `${changeId}-smoke`,
+      title: "Change smoke test",
+      specRef: sources[0] ?? `openspec/changes/${changeId}/`,
+      testFile: `tests/changes/${changeId}.test.ts`,
+      testIds: [`${changeId}-smoke`],
+      required: true
+    });
+  }
+  return cases;
+}
+function extractTaskCases(content, changeId) {
+  const cases = [];
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const numbered = line.match(/^\s*[-*]\s+\[[ xX]?\]\s+((?:\d+(?:\.\d+)*\.?)?)\s*(.+)$/);
+    if (numbered) {
+      const taskId = numbered[1] || String(cases.length + 1);
+      const title = numbered[2]?.trim() ?? taskId;
+      const id = toKebabId(`${changeId}-task-${taskId}`) || `${changeId}-task-${cases.length + 1}`;
+      cases.push({
+        id,
+        title,
+        specRef: title,
+        testFile: suggestTestFile(changeId, id),
+        testIds: [id],
+        required: true
+      });
+      continue;
+    }
+    const plain = line.match(/^\s*[-*]\s+\[[ xX]?\]\s+(.+)$/);
+    if (plain?.[1]) {
+      const title = plain[1].trim();
+      const id = toKebabId(`${changeId}-${title}`) || `${changeId}-task-${cases.length + 1}`;
+      cases.push({
+        id,
+        title,
+        specRef: title,
+        testFile: suggestTestFile(changeId, id),
+        testIds: [id],
+        required: true
+      });
+    }
+  }
+  return cases;
+}
+function extractScenarioCases(content, changeId, source) {
+  const cases = [];
+  const lines = content.split(/\r?\n/);
+  let currentRequirement = "";
+  for (const line of lines) {
+    const req = line.match(/^#{2,4}\s+Requirement:\s*(.+)$/i);
+    if (req?.[1]) {
+      currentRequirement = req[1].trim();
+    }
+    const scenario = line.match(/^#{2,4}\s+Scenario:\s*(.+)$/i);
+    if (scenario?.[1]) {
+      const title = scenario[1].trim();
+      const id = toKebabId(`${changeId}-${title}`) || `${changeId}-scenario-${cases.length + 1}`;
+      cases.push({
+        id,
+        title,
+        specRef: currentRequirement ? `Requirement: ${currentRequirement} \u2014 Scenario: ${title}` : `Scenario: ${title}`,
+        testFile: suggestTestFile(changeId, id),
+        testIds: [id],
+        required: true
+      });
+    }
+  }
+  if (!cases.length && content.trim()) {
+    const id = `${changeId}-spec-smoke`;
+    cases.push({
+      id,
+      title: `Spec coverage for ${source}`,
+      specRef: source,
+      testFile: suggestTestFile(changeId, id),
+      testIds: [id],
+      required: true
+    });
+  }
+  return cases;
+}
+function suggestTestFile(changeId, caseId) {
+  const segment = caseId.replace(new RegExp(`^${changeId}-?`), "") || "suite";
+  return `tests/changes/${changeId}/${segment}.test.ts`;
+}
+
+// src/commands/tdd.ts
+async function tddCommand(ctx) {
+  await withProjectLock(ctx.projectRoot, { command: "tdd", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    const changeId = await resolveChangeId(ctx);
+    await assertChangeExists(ctx, changeId);
+    const config = await loadTddConfig(ctx.projectRoot);
+    const sources = await collectPlanningSources(ctx.projectRoot, changeId);
+    if (!sources.length) {
+      throw new FetError({
+        code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+        message: msg(ctx.language, "\u672A\u627E\u5230\u53EF\u7528\u4E8E\u751F\u6210 TDD \u7684\u89C4\u5212\u4EA7\u7269\u3002", "No planning artifacts found for TDD generation."),
+        details: { changeId },
+        suggestedCommand: `fet continue --change ${changeId}`,
+        recoverable: true
+      });
+    }
+    const planningFingerprint = await computePlanningFingerprint(ctx.projectRoot, changeId);
+    const cases = await extractCasesFromChange(ctx.projectRoot, changeId, sources);
+    const scan = await ctx.scanner.scan(ctx.projectRoot, {});
+    const testCommand2 = scan.commands.test?.command ?? scan.commands["test:unit"]?.command ?? null;
+    const manifest = createTddManifest({
+      changeId,
+      planningFingerprint,
+      sources,
+      cases,
+      testCommand: testCommand2
+    });
+    const manifestPath2 = await writeTddManifest(ctx.projectRoot, manifest);
+    const fetDir = join24(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+    await mkdir8(fetDir, { recursive: true });
+    const instructionsPath = tddInstructionsRelativePath(changeId);
+    const specPath = tddSpecRelativePath(changeId);
+    await atomicWrite(join24(ctx.projectRoot, instructionsPath), renderTddInstructions(changeId, manifest, ctx.language));
+    await atomicWrite(join24(ctx.projectRoot, specPath), renderTddSpec(changeId, manifest, ctx.language));
+    const changeState = await ctx.stateStore.getOrCreateChange(changeId, "implement");
+    changeState.tdd = {
+      status: "ready",
+      generatedAt: manifest.generatedAt,
+      planningFingerprint,
+      manifestPath: manifestPath2
+    };
+    invalidateTestRun(changeState);
+    changeState.currentPhase = "implement";
+    changeState.phases.implement = { status: "in_progress", updatedAt: manifest.generatedAt };
+    await ctx.stateStore.writeChange(changeState);
+    const global = await ctx.stateStore.getOrCreateGlobal();
+    global.activeChangeId = changeId;
+    await ctx.stateStore.writeGlobal(global);
+    ctx.output.result({
+      ok: true,
+      command: "tdd",
+      summary: msg(
+        ctx.language,
+        `\u5DF2\u4E3A change "${changeId}" \u751F\u6210 TDD \u4EA7\u7269\uFF08${cases.length} \u4E2A\u7528\u4F8B\uFF09\u3002`,
+        `Generated TDD artifacts for change "${changeId}" (${cases.length} case(s)).`
+      ),
+      warnings: !testCommand2 && config.whenNoTestScript !== "skip" ? [
+        msg(
+          ctx.language,
+          "\u9879\u76EE\u672A\u914D\u7F6E test \u811A\u672C\uFF1B\u5B9E\u73B0\u540E\u53EF\u80FD\u65E0\u6CD5\u8FD0\u884C fet test\u3002",
+          "No test script found in the project; fet test may fail after implementation."
+        )
+      ] : void 0,
+      nextSteps: [
+        msg(ctx.language, `\u9605\u8BFB ${instructionsPath}\uFF0C\u7531 IDE/AI \u521B\u5EFA/\u66F4\u65B0\u6E05\u5355\u4E2D\u7684\u6D4B\u8BD5\u6587\u4EF6\u3002`, `Read ${instructionsPath} and create/update test files listed in the manifest.`),
+        msg(ctx.language, `\u5B8C\u6210\u540E\u8FD0\u884C fet apply --change ${changeId}`, `Then run fet apply --change ${changeId}`),
+        msg(ctx.language, `\u5B9E\u73B0\u540E\u8FD0\u884C fet test --change ${changeId}`, `After implementation, run fet test --change ${changeId}`)
+      ],
+      data: {
+        changeId,
+        manifestPath: manifestPath2,
+        specPath,
+        instructionsPath,
+        caseCount: cases.length,
+        planningFingerprint,
+        testCommand: testCommand2
+      }
+    });
+  });
+}
+
+// src/commands/run-script.ts
+import { spawn as spawn2 } from "child_process";
+async function runShellCommand(commandLine, cwd, extraArgs = []) {
+  const parts = splitCommandLine(commandLine);
+  const executable = parts[0];
+  if (!executable) {
+    throw new Error("Empty command");
+  }
+  const args = [...parts.slice(1), ...extraArgs];
+  return runProcess(executable, args, cwd, commandLine);
 }
+async function runProcess(executable, args, cwd, label = executable) {
+  return new Promise((resolve2) => {
+    const stdout = [];
+    const stderr = [];
+    const child = spawn2(executable, args, {
+      cwd,
+      shell: process.platform === "win32",
+      env: process.env
+    });
+    child.stdout?.on("data", (chunk) => stdout.push(chunk));
+    child.stderr?.on("data", (chunk) => stderr.push(chunk));
+    child.on("close", (code, signal) => {
+      resolve2({
+        command: label,
+        args,
+        exitCode: code ?? 1,
+        signal,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8")
+      });
+    });
+    child.on("error", () => {
+      resolve2({
+        command: label,
+        args,
+        exitCode: 1,
+        signal: null,
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8")
+      });
+    });
+  });
+}
+function splitCommandLine(commandLine) {
+  return commandLine.trim().split(/\s+/);
+}
+
+// src/commands/test.ts
+async function testCommand(ctx, options) {
+  await withProjectLock(ctx.projectRoot, { command: "test", cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    const changeId = await resolveChangeId(ctx);
+    await assertChangeExists(ctx, changeId);
+    const config = await loadTddConfig(ctx.projectRoot);
+    const manifest = await readTddManifest(ctx.projectRoot, changeId);
+    if (!manifest) {
+      throw new FetError({
+        code: "STATE_CORRUPTED" /* StateCorrupted */,
+        message: msg(ctx.language, "\u7F3A\u5C11 TDD \u6E05\u5355\uFF0C\u65E0\u6CD5\u8FD0\u884C fet test\u3002", "TDD manifest is missing; cannot run fet test."),
+        details: { changeId },
+        suggestedCommand: `fet tdd --change ${changeId}`,
+        recoverable: true
+      });
+    }
+    const planningFingerprint = await computePlanningFingerprint(ctx.projectRoot, changeId);
+    if (manifest.planningFingerprint !== planningFingerprint) {
+      throw new FetError({
+        code: "STATE_CORRUPTED" /* StateCorrupted */,
+        message: msg(ctx.language, "TDD \u6E05\u5355\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C fet tdd\u3002", "TDD manifest is stale; rerun fet tdd."),
+        details: { changeId },
+        suggestedCommand: `fet tdd --change ${changeId}`,
+        recoverable: true
+      });
+    }
+    const scan = await ctx.scanner.scan(ctx.projectRoot, {});
+    const testCommand2 = manifest.run.fallbackCommand ?? scan.commands.test?.command ?? scan.commands["test:unit"]?.command ?? null;
+    if (!testCommand2) {
+      if (config.whenNoTestScript === "skip") {
+        await recordSkippedTestRun(ctx, changeId, planningFingerprint, manifestPath(changeId));
+        ctx.output.result({
+          ok: true,
+          command: "test",
+          summary: msg(ctx.language, "\u672A\u914D\u7F6E test \u811A\u672C\uFF0C\u5DF2\u8DF3\u8FC7 fet test\u3002", "No test script configured; fet test skipped."),
+          warnings: [msg(ctx.language, "\u8DF3\u8FC7\u540E\u53EF\u76F4\u63A5 fet verify\uFF08\u82E5\u9879\u76EE\u7B56\u7565\u5141\u8BB8\uFF09\u3002", "You may proceed to fet verify if your policy allows.")],
+          data: { changeId, skipped: true }
+        });
+        return;
+      }
+      throw new FetError({
+        code: "CONFIG_INVALID" /* ConfigInvalid */,
+        message: msg(ctx.language, "\u672A\u627E\u5230 test \u811A\u672C\uFF0C\u65E0\u6CD5\u6267\u884C fet test\u3002", "No test script found; cannot run fet test."),
+        suggestedCommand: "\u5728 package.json \u4E2D\u6DFB\u52A0 scripts.test \u6216\u914D\u7F6E openspec/config.yaml fet.tdd.whenNoTestScript: skip"
+      });
+    }
+    const extraArgs = buildTestArgs(manifest);
+    const planLabel = `${testCommand2}${extraArgs.length ? ` ${extraArgs.join(" ")}` : ""}`;
+    if (options.plan) {
+      ctx.output.result({
+        ok: true,
+        command: "test",
+        summary: msg(ctx.language, "\u5DF2\u751F\u6210 fet test \u6267\u884C\u8BA1\u5212\u3002", "Generated fet test execution plan."),
+        data: {
+          changeId,
+          command: planLabel,
+          cases: manifest.cases.map((item) => ({ id: item.id, testFile: item.testFile }))
+        },
+        nextSteps: [`fet test --change ${changeId}`]
+      });
+      return;
+    }
+    const result = await runShellCommand(testCommand2, ctx.projectRoot, extraArgs);
+    const caseResults = manifest.cases.map((item) => ({
+      id: item.id,
+      status: result.exitCode === 0 ? "passed" : "failed",
+      exitCode: result.exitCode,
+      message: result.exitCode === 0 ? void 0 : msg(ctx.language, "\u6D4B\u8BD5\u547D\u4EE4\u672A\u901A\u8FC7", "Test command failed")
+    }));
+    const resultsDoc = {
+      schemaVersion: 1,
+      changeId,
+      ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+      command: planLabel,
+      exitCode: result.exitCode,
+      planningFingerprint,
+      cases: caseResults
+    };
+    const resultsPath = await writeTddResults(ctx.projectRoot, resultsDoc);
+    const changeState = await ctx.stateStore.getOrCreateChange(changeId, "implement");
+    changeState.testRun = {
+      status: result.exitCode === 0 ? "passed" : "failed",
+      ranAt: resultsDoc.ranAt,
+      command: planLabel,
+      exitCode: result.exitCode,
+      planningFingerprint,
+      manifestPath: manifestPath(changeId),
+      resultsPath
+    };
+    await ctx.stateStore.writeChange(changeState);
+    if (result.exitCode !== 0) {
+      throw new FetError({
+        code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+        message: msg(ctx.language, "fet test \u672A\u901A\u8FC7\u3002", "fet test failed."),
+        details: {
+          changeId,
+          exitCode: result.exitCode,
+          command: planLabel,
+          resultsPath: tddResultsRelativePath(changeId),
+          stderr: truncate(result.stderr)
+        },
+        suggestedCommand: `fet test --change ${changeId}`,
+        recoverable: true
+      });
+    }
+    ctx.output.result({
+      ok: true,
+      command: "test",
+      summary: msg(ctx.language, `change "${changeId}" \u7684\u5355\u6D4B\u5DF2\u901A\u8FC7\u3002`, `Unit tests passed for change "${changeId}".`),
+      nextSteps: [`fet verify --change ${changeId}`],
+      data: {
+        changeId,
+        command: planLabel,
+        resultsPath: tddResultsRelativePath(changeId),
+        cases: caseResults
+      }
+    });
+  });
+}
+function manifestPath(changeId) {
+  return tddManifestRelativePath(changeId);
+}
+function buildTestArgs(manifest) {
+  if (!manifest || manifest.run.mode === "workspace") {
+    return [];
+  }
+  const files = [...new Set(manifest.cases.map((item) => item.testFile).filter(Boolean))];
+  return files.length ? ["--", ...files] : [];
+}
+async function recordSkippedTestRun(ctx, changeId, planningFingerprint, manifestPathValue) {
+  const changeState = await ctx.stateStore.getOrCreateChange(changeId, "implement");
+  changeState.testRun = {
+    status: "skipped",
+    ranAt: (/* @__PURE__ */ new Date()).toISOString(),
+    command: "(skipped)",
+    exitCode: 0,
+    planningFingerprint,
+    manifestPath: manifestPathValue,
+    resultsPath: null
+  };
+  await ctx.stateStore.writeChange(changeState);
+}
+function truncate(value, max = 2e3) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+
+// src/commands/verify.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdir as mkdir9, readFile as readFile19, stat as stat11 } from "fs/promises";
+import { join as join25 } from "path";
 async function verifyCommand(ctx, options) {
   if (options.auto) {
     const scan = await ctx.scanner.scan(ctx.projectRoot, {});
@@ -4580,10 +5360,11 @@ async function verifyCommand(ctx, options) {
 }
 async function writeInstructions(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
+  await assertTestPassed(ctx, changeId);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join20(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
-  const instructionsPath = join20(dir, "verify-instructions.md");
-  await mkdir7(dir, { recursive: true });
+  const dir = join25(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join25(dir, "verify-instructions.md");
+  await mkdir9(dir, { recursive: true });
   await atomicWrite(instructionsPath, renderVerifyInstructions(changeId, generatedAt));
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
   state.currentPhase = "verify";
@@ -4598,8 +5379,9 @@ async function writeInstructions(ctx, changeId) {
 }
 async function markDone(ctx, changeId) {
   await assertChangeExists(ctx, changeId);
+  await assertTestPassed(ctx, changeId);
   const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
-  const instructionsPath = join20(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
+  const instructionsPath = join25(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
   const instructions = await readInstructions(ctx, instructionsPath, changeId);
   const instructionsGeneratedAt = readFrontMatterValue(instructions, "generatedAt") ?? declaredAt;
   const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
@@ -4621,21 +5403,10 @@ async function markDone(ctx, changeId) {
     nextSteps: [`fet sync --change ${changeId}`, `fet archive --change ${changeId}`]
   });
 }
-async function assertChangeExists(ctx, changeId) {
-  const inspection = await ctx.openSpec.inspectChange(ctx.projectRoot, changeId);
-  if (!inspection.exists) {
-    throw new FetError({
-      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
-      message: msg(ctx.language, "\u6307\u5B9A\u7684 change \u4E0D\u5B58\u5728", "The specified change does not exist"),
-      details: { changeId },
-      suggestedCommand: `fet verify --change ${changeId}`
-    });
-  }
-}
 async function readInstructions(ctx, path, changeId) {
   try {
-    await stat9(path);
-    const content = await readFile15(path, "utf8");
+    await stat11(path);
+    const content = await readFile19(path, "utf8");
     const fileChangeId = readFrontMatterValue(content, "changeId");
     if (fileChangeId !== changeId) {
       throw new FetError({
@@ -4667,26 +5438,7 @@ function readFrontMatterValue(content, key) {
   return match?.[1]?.trim() ?? null;
 }
 function fingerprint(value) {
-  return `sha256:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
-}
-async function resolveChangeId(ctx) {
-  if (ctx.changeId) {
-    return ctx.changeId;
-  }
-  const global = await ctx.stateStore.getOrCreateGlobal();
-  if (global.activeChangeId) {
-    return global.activeChangeId;
-  }
-  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
-  if (inspection.changes.length === 1 && inspection.changes[0]) {
-    return inspection.changes[0];
-  }
-  throw new FetError({
-    code: "INVALID_ARGUMENTS" /* InvalidArguments */,
-    message: msg(ctx.language, "\u65E0\u6CD5\u786E\u5B9A\u8981\u9A8C\u8BC1\u7684 change", "Cannot determine which change to verify"),
-    details: { openChangeIds: inspection.changes },
-    suggestedCommand: "fet verify --change <change-id>"
-  });
+  return `sha256:${createHash2("sha256").update(JSON.stringify(value)).digest("hex")}`;
 }
 
 // src/model-policy.ts
@@ -4777,11 +5529,12 @@ function renderIdeModelPolicy(command, language = "zh-CN") {
 import { resolve } from "path";
 
 // src/adapters/codex/index.ts
-import { mkdir as mkdir8, readFile as readFile16, stat as stat10 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile20, stat as stat12 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname8, join as join21 } from "path";
+import { dirname as dirname9, join as join26 } from "path";
 
 // src/adapters/commands.ts
+var FET_STANDALONE_COMMANDS = ["tdd", "test"];
 var FET_WORKFLOW_COMMANDS = [
   "explore",
   "propose",
@@ -4796,7 +5549,7 @@ var FET_WORKFLOW_COMMANDS = [
   "onboard"
 ];
 var FET_GRAPH_COMMANDS = ["graph-status", "graph-setup", "graph-init", "graph-refresh", "graph-doctor", "graph-handoff"];
-var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, "update", "fill-context", "passthrough", ...FET_GRAPH_COMMANDS];
+var FET_ADAPTER_COMMANDS = [...FET_WORKFLOW_COMMANDS, ...FET_STANDALONE_COMMANDS, "update", "fill-context", "passthrough", ...FET_GRAPH_COMMANDS];
 function renderFetAdapterUsage(command, args = "[...args]") {
   if (command.startsWith("graph-")) {
     const subcommand = command.slice("graph-".length);
@@ -5864,7 +6617,7 @@ var CodexAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists5(join21(projectRoot, ".codex")) || await exists5(join21(projectRoot, "AGENTS.md")),
+      detected: await exists6(join26(projectRoot, ".codex")) || await exists6(join26(projectRoot, "AGENTS.md")),
       reason: "Codex adapter is available for projects that use AGENTS.md"
     };
   }
@@ -5903,7 +6656,7 @@ var CodexAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && force) {
         await createBackup(target);
       }
-      await mkdir8(dirname8(target), { recursive: true });
+      await mkdir10(dirname9(target), { recursive: true });
       await atomicWrite(target, file.content);
       written.push(displayPath);
     }
@@ -5930,9 +6683,9 @@ var CodexAdapter = class {
 };
 function resolveTarget(projectRoot, file) {
   if (file.root === "codex-home") {
-    return join21(resolveCodexHome(), file.path);
+    return join26(resolveCodexHome(), file.path);
   }
-  return join21(projectRoot, file.path);
+  return join26(projectRoot, file.path);
 }
 function displayPathFor(file) {
   if (file.root === "codex-home") {
@@ -5941,18 +6694,18 @@ function displayPathFor(file) {
   return file.path;
 }
 function resolveCodexHome() {
-  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join21(homedir(), ".codex");
+  return process.env.FET_CODEX_HOME ?? process.env.CODEX_HOME ?? join26(homedir(), ".codex");
 }
 async function readExisting(path) {
   try {
-    return await readFile16(path, "utf8");
+    return await readFile20(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists5(path) {
+async function exists6(path) {
   try {
-    await stat10(path);
+    await stat12(path);
     return true;
   } catch {
     return false;
@@ -5960,8 +6713,8 @@ async function exists5(path) {
 }
 
 // src/adapters/cursor/index.ts
-import { mkdir as mkdir9, readFile as readFile17, stat as stat11 } from "fs/promises";
-import { dirname as dirname9, join as join22 } from "path";
+import { mkdir as mkdir11, readFile as readFile21, stat as stat13 } from "fs/promises";
+import { dirname as dirname10, join as join27 } from "path";
 
 // src/adapters/cursor/templates.ts
 function cursorFigmaStopRuleFile(language = DEFAULT_LANGUAGE) {
@@ -6093,6 +6846,9 @@ After installation, verify with \`gitnexus --version\`, then run \`fet graph ini
   if (command === "apply") {
     return renderApplySkill(usage, language);
   }
+  if (command === "tdd" || command === "test") {
+    return renderTddTestSkill(command, usage, language);
+  }
   if (command === "propose" || command === "continue" || command === "ff") {
     return renderPlanningSkill(command, usage, language);
   }
@@ -6210,6 +6966,38 @@ ${figmaBlock}
 ${uiContractBlock}
 
 \u6267\u884C\u524D\u8BF7\u9605\u8BFB AGENTS.md\u3001openspec/config.yaml \u4E0E\u5F53\u524D change \u4E0B\u7684 OpenSpec \u4EA7\u7269\u3002
+
+\u5B9E\u65BD\u524D\u987B\u5DF2\u8FD0\u884C \`fet tdd\`\uFF1B\u5B58\u5728 \`openspec/changes/<change-id>/.fet/tdd-manifest.yaml\` \u65F6\u6309\u6E05\u5355\u7F16\u5199\u6D4B\u8BD5\u4E0E\u5B9E\u73B0\uFF0C\u5E76\u5728 \`fet verify\` \u524D\u5148 \`fet test\`\u3002
+`;
+}
+function renderTddTestSkill(command, usage, language) {
+  const description = command === "tdd" ? language === "en" ? "Generate per-change TDD manifest and test instructions" : "\u751F\u6210\u672C change \u7684 TDD \u6E05\u5355\u4E0E\u6D4B\u8BD5\u6307\u5F15" : language === "en" ? "Run unit tests scoped to the change TDD manifest" : "\u6309 change TDD \u6E05\u5355\u8FD0\u884C\u5355\u6D4B";
+  const body = command === "tdd" ? language === "en" ? `After planning artifacts exist, run this before \`fet apply\`. It writes \`openspec/changes/<change-id>/.fet/tdd-manifest.yaml\`, \`tdd-spec.md\`, and \`tdd-instructions.md\`. Then create failing tests in the repo before implementation.` : `\u89C4\u5212\u4EA7\u7269\u5C31\u7EEA\u540E\u3001\`fet apply\` \u4E4B\u524D\u8FD0\u884C\u3002\u4F1A\u5199\u5165 \`openspec/changes/<change-id>/.fet/tdd-manifest.yaml\`\u3001\`tdd-spec.md\`\u3001\`tdd-instructions.md\`\uFF0C\u518D\u5728\u4ED3\u5E93\u4E2D\u7F16\u5199\u9884\u671F\u5931\u8D25\u7684\u6D4B\u8BD5\u3002` : language === "en" ? `Run after implementation. Requires a current \`tdd-manifest.yaml\`. Records pass/fail in FET state; \`fet verify\` is blocked until this passes (unless configured to skip).` : `\u5B9E\u73B0\u5B8C\u6210\u540E\u8FD0\u884C\u3002\u9700\u8981\u6709\u6548\u7684 \`tdd-manifest.yaml\`\u3002\u7ED3\u679C\u5199\u5165 FET \u72B6\u6001\uFF1B\u672A\u901A\u8FC7\u524D \`fet verify\` \u4F1A\u88AB\u62E6\u622A\uFF08\u9664\u975E\u914D\u7F6E\u4E3A skip\uFF09\u3002`;
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: cursor-adapter
+adapterVersion: 1
+command: ${usage}
+FET:END -->
+
+---
+name: fet-${command}
+description: ${description}
+disable-model-invocation: true
+---
+
+${renderIdeModelPolicy(command, language)}
+
+${languageInstruction(language)}
+
+\u8BF7\u5728\u7EC8\u7AEF\u4E2D\u6267\u884C\uFF1A
+
+\`\`\`sh
+${usage}
+\`\`\`
+
+${body}
 `;
 }
 
@@ -6219,7 +7007,7 @@ var CursorAdapter = class {
   adapterVersion = 1;
   async detect(projectRoot) {
     return {
-      detected: await exists6(join22(projectRoot, ".cursor")),
+      detected: await exists7(join27(projectRoot, ".cursor")),
       reason: "Cursor adapter is available for any project"
     };
   }
@@ -6236,7 +7024,7 @@ var CursorAdapter = class {
     const written = [];
     const skipped = [];
     for (const file of plan.files) {
-      const target = join22(projectRoot, file.path);
+      const target = join27(projectRoot, file.path);
       const existing = await readExisting2(target);
       if (existing && !existing.includes("FET:MANAGED") && !force) {
         throw new FetError({
@@ -6249,7 +7037,7 @@ var CursorAdapter = class {
       if (existing && !existing.includes("FET:MANAGED") && force) {
         await createBackup(target);
       }
-      await mkdir9(dirname9(target), { recursive: true });
+      await mkdir11(dirname10(target), { recursive: true });
       await atomicWrite(target, file.content);
       written.push(file.path);
     }
@@ -6259,7 +7047,7 @@ var CursorAdapter = class {
     const plan = await this.planInstall(projectRoot);
     const checks = [];
     for (const file of plan.files) {
-      const target = join22(projectRoot, file.path);
+      const target = join27(projectRoot, file.path);
       const content = await readExisting2(target);
       const managed = Boolean(content?.includes("FET:MANAGED"));
       const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
@@ -6275,14 +7063,14 @@ var CursorAdapter = class {
 };
 async function readExisting2(path) {
   try {
-    return await readFile17(path, "utf8");
+    return await readFile21(path, "utf8");
   } catch {
     return null;
   }
 }
-async function exists6(path) {
+async function exists7(path) {
   try {
-    await stat11(path);
+    await stat13(path);
     return true;
   } catch {
     return false;
@@ -6294,45 +7082,45 @@ import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 
 // src/openspec/inspector.ts
-import { readdir as readdir5, stat as stat12 } from "fs/promises";
-import { join as join23 } from "path";
+import { readdir as readdir6, stat as stat14 } from "fs/promises";
+import { join as join28 } from "path";
 async function inspectOpenSpecProject(projectRoot) {
-  const openspecPath = join23(projectRoot, "openspec");
-  const changesPath = join23(openspecPath, "changes");
-  const legacyArchivePath = join23(openspecPath, "archive");
-  const changesArchivePath = join23(changesPath, "archive");
+  const openspecPath = join28(projectRoot, "openspec");
+  const changesPath = join28(openspecPath, "changes");
+  const legacyArchivePath = join28(openspecPath, "archive");
+  const changesArchivePath = join28(changesPath, "archive");
   return {
-    exists: await exists7(openspecPath),
+    exists: await exists8(openspecPath),
     changes: await listDirectories(changesPath, { exclude: ["archive"] }),
     archived: [.../* @__PURE__ */ new Set([...await listDirectories(legacyArchivePath), ...await listDirectories(changesArchivePath)])]
   };
 }
 async function inspectOpenSpecChange(projectRoot, changeId) {
-  const changePath = join23(projectRoot, "openspec", "changes", changeId);
-  const tasksPath = join23(changePath, "tasks.md");
-  const specsPath = join23(changePath, "specs");
+  const changePath = join28(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join28(changePath, "tasks.md");
+  const specsPath = join28(changePath, "specs");
   return {
     changeId,
-    exists: await exists7(changePath),
-    hasProposal: await exists7(join23(changePath, "proposal.md")),
-    hasTasks: await exists7(tasksPath),
-    hasSpecs: await exists7(specsPath),
+    exists: await exists8(changePath),
+    hasProposal: await exists8(join28(changePath, "proposal.md")),
+    hasTasks: await exists8(tasksPath),
+    hasSpecs: await exists8(specsPath),
     tasksPath,
     changePath
   };
 }
 async function listDirectories(path, options = {}) {
   try {
-    const entries = await readdir5(path, { withFileTypes: true });
+    const entries = await readdir6(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 exists7(path) {
+async function exists8(path) {
   try {
-    await stat12(path);
+    await stat14(path);
     return true;
   } catch {
     return false;
@@ -6399,14 +7187,14 @@ function exec(command, args) {
 }
 
 // src/openspec/runner.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 async function runOpenSpec(executablePath, command, args, options) {
   const spawnCommand = executablePath === "npx openspec" ? "npx" : executablePath;
   const spawnArgs = executablePath === "npx openspec" ? ["openspec", command, ...args] : [command, ...args];
   return new Promise((resolve2, reject) => {
     const stdout = [];
     const stderr = [];
-    const child = spawn2(spawnCommand, spawnArgs, {
+    const child = spawn3(spawnCommand, spawnArgs, {
       cwd: options.cwd,
       stdio: options.stdio ?? "inherit",
       shell: process.platform === "win32"
@@ -6515,14 +7303,14 @@ function escapeRegExp(value) {
 }
 
 // src/scanner/routes.ts
-import { readdir as readdir6, stat as stat13 } from "fs/promises";
-import { join as join24, relative as relative4, sep } from "path";
+import { readdir as readdir7, stat as stat15 } from "fs/promises";
+import { join as join29, relative as relative5, sep } from "path";
 async function scanRoutes(projectRoot) {
   const candidates = ["src/routes", "src/pages", "app", "pages"];
   const routes = [];
   for (const candidate of candidates) {
-    const root = join24(projectRoot, candidate);
-    if (!await exists8(root)) {
+    const root = join29(projectRoot, candidate);
+    if (!await exists9(root)) {
       continue;
     }
     for (const file of await listFiles(root)) {
@@ -6530,8 +7318,8 @@ async function scanRoutes(projectRoot) {
         continue;
       }
       routes.push({
-        path: inferRoutePath(relative4(root, file)),
-        source: relative4(projectRoot, file).split(sep).join("/"),
+        path: inferRoutePath(relative5(root, file)),
+        source: relative5(projectRoot, file).split(sep).join("/"),
         inferred: true,
         confidence: "medium"
       });
@@ -6546,10 +7334,10 @@ function inferRoutePath(relativePath) {
   return `/${withoutIndex}`.replace(/\/+/g, "/");
 }
 async function listFiles(root) {
-  const entries = await readdir6(root, { withFileTypes: true });
+  const entries = await readdir7(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join24(root, entry.name);
+    const path = join29(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFiles(path));
     } else {
@@ -6558,9 +7346,9 @@ async function listFiles(root) {
   }
   return files;
 }
-async function exists8(path) {
+async function exists9(path) {
   try {
-    await stat13(path);
+    await stat15(path);
     return true;
   } catch {
     return false;
@@ -6717,9 +7505,9 @@ async function createCommandContext(command, options) {
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/update/check.ts
-import { mkdir as mkdir10, readFile as readFile18, writeFile } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile22, writeFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname10, join as join25 } from "path";
+import { dirname as dirname11, join as join30 } from "path";
 var DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
 function getFetUpdateCheckMode(env = process.env) {
   const value = env.FET_UPDATE_CHECK?.trim().toLowerCase();
@@ -6792,11 +7580,11 @@ function formatFetUpdateWarning(availability, language) {
 }
 function cachePath() {
   const home = process.env.FET_UPDATE_CHECK_CACHE_HOME?.trim() || homedir2();
-  return join25(home, ".fet", "update-check-cache.json");
+  return join30(home, ".fet", "update-check-cache.json");
 }
 async function readUpdateCheckCache() {
   try {
-    const raw = await readFile18(cachePath(), "utf8");
+    const raw = await readFile22(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.latestVersion !== "string" || typeof parsed.checkedAt !== "string") {
       return null;
@@ -6812,7 +7600,7 @@ async function readUpdateCheckCache() {
 }
 async function writeUpdateCheckCache(cache) {
   const path = cachePath();
-  await mkdir10(dirname10(path), { recursive: true });
+  await mkdir12(dirname11(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
@@ -6899,6 +7687,10 @@ for (const action of ["init", "refresh"]) {
 addGlobalOptions(program.command("doctor").description("\u8BCA\u65AD\u72B6\u6001\u3001\u914D\u7F6E\u4E0E\u4E00\u81F4\u6027").option("--fix-lock", "\u6E05\u7406 FET \u9501\u6587\u4EF6")).action(
   wrap("doctor", (ctx, options) => doctorCommand(ctx, { fixLock: Boolean(options.fixLock) }))
 );
+addGlobalOptions(program.command("tdd").description("\u6839\u636E\u89C4\u5212\u4EA7\u7269\u751F\u6210 change \u7EA7 TDD \u6E05\u5355\u4E0E\u6D4B\u8BD5\u6307\u5F15")).action(wrap("tdd", tddCommand));
+addGlobalOptions(program.command("test").description("\u6309 change TDD \u6E05\u5355\u8FD0\u884C\u5355\u6D4B\u5E76\u8BB0\u5F55\u7EFF\u706F\u72B6\u6001").option("--plan", "\u4EC5\u8F93\u51FA\u5C06\u6267\u884C\u7684\u6D4B\u8BD5\u547D\u4EE4\uFF0C\u4E0D\u8FD0\u884C")).action(
+  wrap("test", (ctx, options) => testCommand(ctx, { plan: Boolean(options.plan) }))
+);
 addGlobalOptions(program.command("verify").description("\u6700\u7EC8\u8D28\u91CF\u9A8C\u8BC1").option("--done", "\u58F0\u660E\u624B\u52A8\u9A8C\u8BC1\u5DF2\u5B8C\u6210").option("--auto", "\u751F\u6210\u6216\u6267\u884C\u81EA\u52A8\u9A8C\u8BC1\u8BA1\u5212")).action(
   wrap("verify", verifyCommand)
 );