@devflow-core/dsh-devflow 0.5.0 → 0.6.0

package/assets/commands/devflow.toml

@@ -12,7 +12,7 @@ Use Fast for pure Q&A, fact lookup, verification, or an already approved trivial
 Use Design-lite when the risk gate skips Brainstorm for a small unapproved change to an existing feature with all low-risk conditions holding. Design-lite states goal, acceptance, and exclusions, records Depth C, and selects Cut then Build. It does not wait for Brainstorm. Not for new requirements.
 If the boundary is unclear after Brainstorm, have Core select the smallest compatible route instead of guessing.
 Run Sense first by reading or citing relevant project facts.
-At Sense, probe `.copilot/LEARNING_INDEX.md` and `docs/project-knowledge/` when present. Read only matched learning cards or navigation-selected knowledge documents; missing locations are non-blocking and do not create storage.
+At Sense, match the task keywords against `docs/features/INDEX.md` and `docs/plans/INDEX.md` when present and open only the matched row's entry file or ledger section (an index over 40 rows is filtered with `node scripts/devflow-plan.js --index --query 关键词`); do not bulk-read capability documents. Then probe `.copilot/LEARNING_INDEX.md` (global preference cards first) and `docs/project-knowledge/`, reading only matched learning cards or navigation-selected knowledge documents and applying known developer preferences; missing locations are non-blocking and do not create storage.
 The direct success map is Skip-Brainstorm Design-lite: Cut -> Build -> Prove, A: Brainstorm -> Spec -> Cut -> Plan -> Build -> Prove, B: Brainstorm -> Cut -> Plan -> Build -> Prove, C: Brainstorm -> Cut -> Build -> Prove. An approved A Spec directly starts Cut; A/B `CUT_PASS` directly starts Plan; C `CUT_PASS` and a skip-path `CUT_PASS` directly start Build; an approved A/B Plan directly starts Build; a completed Build directly starts Prove.
 Before implementation, run Cut with Required Gates: Reuse, Native, Overbuild, Diff, and Scope checks. Core keeps non-unique selection: `CUT_REDUCE`/`CUT_REUSE` STOP for user confirmation, then return facts to Core; `CUT_BLOCKED`, Plan scope drift, `BUILD_BLOCKED`, Proof `FAIL`/`BLOCKED`, changed intent, and PUA recovery return facts so Core chooses the next owner.
 For bug fixes, include Root-Cause Check: searched callers/references; shared vs narrow fix; reason.

package/assets/scripts/devflow-plan.js

@@ -1,4 +1,5 @@
 const fs = require("node:fs");
+const path = require("node:path");
 
 const requiredGlobalFields = ["Goal", "Architecture", "Tech Stack", "Source", "Spec coverage", "External Skills"];
 const requiredTaskFields = ["Task", "Task type", "Files", "Interfaces", "Steps", "Acceptance", "Verify", "Comments", "Not doing"];
@@ -38,10 +39,32 @@ const worklistItemPattern = /^\s*-\s*\[ \]\s+(.+)$/gim;
 const worklistDetailNames = ["Anchors", "Verify", "Done when"];
 const maximumWorklistItems = 12;
 
+// v2 契约（2026-09-10 可用性重构）：计划只保留排序与验收字段；实现改法归 Build。
+// 判定：含 `## Progress` 且不含 `Prewalk` 视为 v2；否则走 legacy 分支，旧计划无需迁移。
+const v2GlobalFields = ["Goal", "Not doing", "Cut"];
+const v2TaskFields = ["Task", "Files", "Change", "Acceptance", "Verify", "Not doing"];
+const v2AllFields = [...v2GlobalFields, ...v2TaskFields];
+const v2FieldPatterns = Object.fromEntries(
+  v2AllFields.map((field) => [field, new RegExp(`^(?:\\*\\*)?${field}(?:\\*\\*)?\\s*:`, "im")])
+);
+const progressHeadingPattern = /^##\s+Progress\s*$/im;
+const progressRowPattern = /^\s*\|\s*(\d+)\s*\|\s*([^|]*)\|\s*(todo|doing|done)\s*\|\s*([^|]*)\|/gim;
+const indexStatuses = ["active", "planned", "legacy", "retired"];
+const indexPaths = { plans: "docs/plans/INDEX.md", features: "docs/features/INDEX.md" };
+// 需求台账：一条需求从确认到落地的唯一记录；opt-out 表示用户显式跳过文档（仍必须有验证证据与原因）。
+const requirementPath = "docs/requirements.md";
+const requirementStatuses = ["open", "designed", "planned", "built", "landed", "opt-out", "dropped"];
+const terminalRequirementStatuses = ["landed", "opt-out", "dropped"];
+const promotionConfidence = 0.7;
+
 /** Print the checker command contract and default plan landing. */
 function usage() {
-  console.log("Usage: node scripts/devflow-plan.js [plan-file] [--self-test] [--json]");
+  console.log("Usage: node scripts/devflow-plan.js [plan-file] [--index] [--self-test] [--json]");
   console.log("Checks whether a DevFlow Plan Pack has an executable header, task contracts, and plan landing.");
+  console.log("v2 plans carry a slim header, per-task Files/Change/Acceptance/Verify/Not doing, and a ## Progress table; legacy plans keep the old contract.");
+  console.log("--index checks docs/plans/INDEX.md and docs/features/INDEX.md against the filesystem.");
+  console.log("--index --query <keyword> prints only matching index rows for progressive loading; an empty result still exits 0.");
+  console.log("--loop prints a read-only loop report: requirement status counts, plan landing rate, feature rows, and promotion candidates.");
   console.log("Default plan landing is docs/plans/YYYY-MM-DD-<short-kebab-name>.md unless the project documents another plan path.");
   console.log("--json prints a single-line machine-readable summary; optional Status header values: " + validStatuses.join(" | "));
 }
@@ -311,8 +334,369 @@ function checkTask(task, fileStructure) {
   };
 }
 
-/** Validate global plan headers and all independently scoped task contracts. */
+/** v2 计划判定：新格式带 Progress 表且不含 Prewalk；旧格式继续走 legacy 校验。 */
+function detectV2(body) {
+  return progressHeadingPattern.test(body) && !/^\s*Prewalk\s*:\s*$/im.test(body);
+}
+
+/** Extract one v2 field block; ends at the next v1 or v2 field line. */
+function v2FieldBlock(body, field) {
+  const lines = body.split(/\r?\n/);
+  const start = lines.findIndex((line) => v2FieldPatterns[field].test(line));
+  if (start < 0) return "";
+
+  const value = lines[start].replace(v2FieldPatterns[field], "").trim();
+  const end = lines.findIndex(
+    (line, index) =>
+      index > start && (v2AllFields.some((name) => v2FieldPatterns[name].test(line)) || /^#{1,6}\s+\S/.test(line))
+  );
+  return [value, ...lines.slice(start + 1, end < 0 ? lines.length : end)].join("\n").trim();
+}
+
+/** Split a v2 plan at Task fields; the Progress table is not part of any task body. */
+function splitTasksV2(body) {
+  const lines = body.split(/\r?\n/);
+  const progressIndex = lines.findIndex((line) => progressHeadingPattern.test(line));
+  const limit = progressIndex < 0 ? lines.length : progressIndex;
+  const taskStarts = [];
+  lines.forEach((line, index) => {
+    if (index < limit && v2FieldPatterns.Task.test(line)) taskStarts.push(index);
+  });
+  return taskStarts.map((start, index) => {
+    const end = taskStarts[index + 1] ?? limit;
+    return { number: index + 1, body: lines.slice(start, end).join("\n") };
+  });
+}
+
+/** Validate one v2 task: files, change intent, acceptance, proof, and exclusion. */
+function checkTaskV2(task) {
+  const missing = v2TaskFields.filter((field) => !v2FieldPatterns[field].test(task.body));
+  const files = v2FieldBlock(task.body, "Files");
+  const change = v2FieldBlock(task.body, "Change");
+  const verify = v2FieldBlock(task.body, "Verify");
+  const notDoing = v2FieldBlock(task.body, "Not doing");
+  const fileEntries = parseFileEntries(files);
+  const invalidFiles = fileEntries.filter(({ match }) => !match).map(({ line }) => line);
+  const unlocatedCodeFiles = findUnlocatedCodeFiles(fileEntries);
+  const unresolved = findMatches(task.body, unresolvedPatterns);
+  const vague = findMatches([change, v2FieldBlock(task.body, "Acceptance"), verify].join("\n"), vaguePatterns);
+  // v2 不强制精确改法；只要求 Change 说出可执行意图，具体实现归 Build。
+  const missingChange = !implementationVerbPattern.test(change) || genericMechanicsPattern.test(change);
+  const incompleteVerification = !hasVerificationExpectation(verify);
+
+  return {
+    number: task.number,
+    missing,
+    unresolved,
+    vague,
+    invalidFiles,
+    unlocatedCodeFiles,
+    missingChange,
+    incompleteVerification,
+    missingNotDoing: !notDoing,
+    ok:
+      missing.length === 0 &&
+      unresolved.length === 0 &&
+      vague.length === 0 &&
+      invalidFiles.length === 0 &&
+      unlocatedCodeFiles.length === 0 &&
+      !missingChange &&
+      !incompleteVerification &&
+      Boolean(notDoing)
+  };
+}
+
+/** Validate the v2 plan contract: slim header, task rows, Progress table, and Cut subtraction. */
+function checkPlanV2(body) {
+  const tasks = splitTasksV2(body);
+  const taskResults = tasks.map(checkTaskV2);
+  const missingGlobal = v2GlobalFields.filter((field) => !v2FieldPatterns[field].test(body));
+  const cutBlock = v2FieldBlock(body, "Cut");
+  const missingRejected = !/Rejected\s*:\s*\S/im.test(cutBlock);
+  const statusMatch = body.match(statusPattern);
+  const status = statusMatch ? statusMatch[1].trim() : "legacy";
+  const invalidStatus = statusMatch ? !validStatuses.includes(status) : false;
+  const progress = [...body.matchAll(progressRowPattern)].map((match) => ({
+    number: Number(match[1]),
+    state: match[3],
+    evidence: match[4].trim()
+  }));
+  const missingEvidence = progress.filter((row) => row.state === "done" && (!row.evidence || row.evidence === "-"));
+  const progressMismatch = progress.length !== tasks.length;
+  const doneStatusNeedsAllDone = status === "done" && progress.some((row) => row.state !== "done");
+
+  return {
+    v2: true,
+    status,
+    invalidStatus,
+    missingGlobal,
+    cut: { missingRejected },
+    tasks: taskResults,
+    progress: { count: progress.length, mismatch: progressMismatch, missingEvidence },
+    doneStatusNeedsAllDone,
+    ok:
+      missingGlobal.length === 0 &&
+      !missingRejected &&
+      !invalidStatus &&
+      tasks.length > 0 &&
+      taskResults.every((task) => task.ok) &&
+      !progressMismatch &&
+      missingEvidence.length === 0 &&
+      !doneStatusNeedsAllDone
+  };
+}
+
+/** Read every markdown table in a file as header cells plus data rows, skipping separator rows. */
+function readMarkdownTables(filePath) {
+  const lines = fs.readFileSync(filePath, "utf8").split(/\r?\n/);
+  const tables = [];
+  let current = [];
+  for (const line of lines) {
+    if (/^\s*\|/.test(line)) {
+      current.push(line.split("|").slice(1, -1).map((cell) => cell.trim()));
+      continue;
+    }
+    if (current.length) {
+      tables.push(current);
+      current = [];
+    }
+  }
+  if (current.length) tables.push(current);
+  return tables
+    .map((cells) => cells.filter((row) => !row.every((cell) => /^:?-{2,}:?$/.test(cell))))
+    .filter((cells) => cells.length > 1)
+    .map((cells) => ({ header: cells[0], rows: cells.slice(1) }));
+}
+
+/** Read the first markdown table into its header cells and data rows. */
+function readMarkdownTable(filePath) {
+  return readMarkdownTables(filePath)[0] || { header: [], rows: [] };
+}
+
+/** Resolve named column positions from the table header so a new column cannot shift the checks. */
+function columnIndexes(header, names) {
+  return Object.fromEntries(names.map((name) => [name, header.findIndex((cell) => cell.includes(name))]));
+}
+
+/** Read one index file's data rows, returning an empty list when the index does not exist yet. */
+function readIndexRows(root, kind) {
+  const filePath = path.join(root, ...indexPaths[kind].split("/"));
+  return fs.existsSync(filePath) ? readMarkdownTable(filePath).rows : [];
+}
+
+/** Return index rows whose text contains the query, for progressive index loading. */
+function matchIndexRows(rows, query) {
+  const needle = String(query || "").trim().toLowerCase();
+  if (!needle) return [];
+  return rows.filter((cells) => cells.join(" ").toLowerCase().includes(needle));
+}
+
+/** Read the value after a flag, or an empty string when it is absent or looks like another flag. */
+function argValue(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 && args[index + 1] && !args[index + 1].startsWith("-") ? args[index + 1] : "";
+}
+
+/** Check docs/plans/INDEX.md and docs/features/INDEX.md against the filesystem. */
+function checkIndexes(root) {
+  const problems = [];
+  const plansDir = path.join(root, "docs", "plans");
+  const featuresDir = path.join(root, "docs", "features");
+  const plansIndex = path.join(root, ...indexPaths.plans.split("/"));
+  const featuresIndex = path.join(root, ...indexPaths.features.split("/"));
+  const planFiles = fs.existsSync(plansDir)
+    ? fs.readdirSync(plansDir).filter((name) => name.endsWith(".md") && name !== "INDEX.md")
+    : [];
+  const planRows = readIndexRows(root, "plans");
+  const featureRows = readIndexRows(root, "features");
+  const plansTable = fs.existsSync(plansIndex) ? readMarkdownTable(plansIndex) : { header: [] };
+  const featuresTable = fs.existsSync(featuresIndex) ? readMarkdownTable(featuresIndex) : { header: [] };
+  const planCols = columnIndexes(plansTable.header, ["计划", "Status", "落地证据", "功能条目"]);
+  const featureCols = columnIndexes(featuresTable.header, ["功能", "Status", "关键文件", "来源计划"]);
+
+  if (planFiles.length > 0 && !fs.existsSync(plansIndex)) {
+    problems.push("docs/plans/INDEX.md missing while plan files exist");
+  }
+  for (const file of planFiles) {
+    const rows = planRows.filter((cells) => cells.some((cell) => cell.includes(file)));
+    if (rows.length === 0) problems.push(`plan not listed in docs/plans/INDEX.md: ${file}`);
+    if (rows.length > 1) problems.push(`plan listed more than once in docs/plans/INDEX.md: ${file}`);
+  }
+  for (const cells of planRows) {
+    const link = cells.find((cell) => cell.includes(".md"));
+    const file = link ? (link.match(/([^()/]+\.md)/) || [])[1] : null;
+    if (!file) continue;
+    if (!planFiles.includes(file)) problems.push(`docs/plans/INDEX.md lists unknown plan: ${file}`);
+    const filePath = path.join(plansDir, file);
+    if (!fs.existsSync(filePath)) continue;
+    const body = fs.readFileSync(filePath, "utf8");
+    const statusMatch = body.match(statusPattern);
+    const expected = statusMatch ? statusMatch[1].trim() : "legacy";
+    const rowStatus = (cells[planCols.Status] || "").trim();
+    if (rowStatus && rowStatus !== expected) {
+      problems.push(`status mismatch for ${file}: index ${rowStatus} vs file ${expected}`);
+    }
+    const evidence = (cells[planCols["落地证据"]] || "").trim();
+    if (rowStatus === "done" && (!evidence || evidence === "-")) {
+      problems.push(`done plan needs landing evidence in docs/plans/INDEX.md: ${file}`);
+    }
+    const featureCell = (cells[planCols["功能条目"]] || "").trim();
+    if (featureCell && featureCell !== "-" && !featureRows.some((row) => (row[featureCols["功能"]] || "").includes(featureCell))) {
+      problems.push(`feature entry not found in docs/features/INDEX.md: ${featureCell}`);
+    }
+  }
+  for (const cells of featureRows) {
+    const status = (cells[featureCols.Status] || "").trim();
+    if (status && !indexStatuses.includes(status)) {
+      problems.push(`invalid feature status in docs/features/INDEX.md: ${status}`);
+    }
+    const files = (cells[featureCols["关键文件"]] || "").split(",").map((value) => value.replaceAll("`", "").trim()).filter((value) => value && value !== "-");
+    for (const rel of files) {
+      if (!fs.existsSync(path.join(root, rel))) problems.push(`feature file missing: ${rel}`);
+    }
+    const plan = (cells[featureCols["来源计划"]] || "").replaceAll("`", "").trim();
+    if (plan && plan !== "-" && !fs.existsSync(path.join(root, "docs", "plans", plan))) {
+      problems.push(`feature source plan missing: ${plan}`);
+    }
+  }
+  const requirementTable = readRequirementTable(root);
+  problems.push(
+    ...checkRequirementTable(requirementTable.header, requirementTable.rows, (rel) => fs.existsSync(path.join(root, rel)))
+  );
+  return problems;
+}
+
+/** Run the plan and feature index consistency check, or answer a single query. */
+function runIndexCheck(json, query) {
+  const root = path.resolve(__dirname, "..");
+  if (query) {
+    const featureMatches = matchIndexRows(readIndexRows(root, "features"), query);
+    const planMatches = matchIndexRows(readIndexRows(root, "plans"), query);
+    if (json) {
+      console.log(JSON.stringify({ checker: "plan-index-query", query, features: featureMatches, plans: planMatches, judgment: "PASS" }));
+    } else {
+      console.log(`DevFlow index query: ${query}`);
+      for (const cells of featureMatches) console.log(`功能行: ${cells.join(" | ")}`);
+      for (const cells of planMatches) console.log(`计划行: ${cells.join(" | ")}`);
+      console.log(`Matches: ${featureMatches.length + planMatches.length}`);
+    }
+    return 0;
+  }
+  const problems = checkIndexes(root);
+  if (json) {
+    console.log(JSON.stringify({ checker: "plan-index", problems, judgment: problems.length === 0 ? "PASS" : "FAIL" }));
+  } else {
+    console.log("DevFlow plan and feature index report");
+    console.log(`Index files: ${indexPaths.plans} | ${indexPaths.features}`);
+    if (problems.length === 0) console.log("Problems: none");
+    for (const problem of problems) console.log(`Problem: ${problem}`);
+    console.log(`Judgment: ${problems.length === 0 ? "PASS" : "FAIL"}`);
+  }
+  return problems.length === 0 ? 0 : 1;
+}
+
+/** Validate the requirement ledger table: status whitelist, terminal evidence, opt-out reason, artifact paths. */
+function checkRequirementTable(header, rows, exists) {
+  const problems = [];
+  const cols = columnIndexes(header, ["需求", "日期", "落地物", "状态", "证据或跳过"]);
+  if (cols["状态"] < 0 || cols["证据或跳过"] < 0) {
+    problems.push("docs/requirements.md header must contain 状态 and 证据或跳过 columns");
+    return problems;
+  }
+  for (const cells of rows) {
+    const requirement = (cells[cols["需求"]] || "").trim();
+    const date = cols["日期"] >= 0 ? (cells[cols["日期"]] || "").trim() : "";
+    const status = (cells[cols["状态"]] || "").trim();
+    const evidence = (cells[cols["证据或跳过"]] || "").trim();
+    if (!requirement) problems.push("requirement row missing 需求 text");
+    if (!date) problems.push(`requirement row missing 日期: ${requirement}`);
+    if (!requirementStatuses.includes(status)) problems.push(`invalid requirement status: ${status}`);
+    if (terminalRequirementStatuses.includes(status) && (!evidence || evidence === "-")) {
+      problems.push(`terminal requirement needs evidence: ${requirement}`);
+    }
+    if (status === "opt-out" && !/原因|reason|skip/i.test(evidence)) {
+      problems.push(`opt-out needs a recorded reason: ${requirement}`);
+    }
+    const artifacts = (cells[cols["落地物"]] || "")
+      .split(",")
+      .map((value) => value.replaceAll("`", "").trim())
+      .filter((value) => value && value !== "-");
+    for (const rel of artifacts) {
+      if (!exists(rel)) problems.push(`requirement artifact missing: ${rel}`);
+    }
+  }
+  return problems;
+}
+
+/** Read the requirement ledger table, selecting the table that carries the ledger columns. */
+function readRequirementTable(root) {
+  const filePath = path.join(root, ...requirementPath.split("/"));
+  if (!fs.existsSync(filePath)) return { header: [], rows: [] };
+  const tables = readMarkdownTables(filePath);
+  const ledger = tables.find(
+    (table) => table.header.some((cell) => cell.includes("状态")) && table.header.some((cell) => cell.includes("证据或跳过"))
+  );
+  return ledger || tables[0] || { header: [], rows: [] };
+}
+
+/** Count requirement statuses and promotion candidates for the read-only loop report. */
+function summarizeLoop(root) {
+  const { header, rows } = readRequirementTable(root);
+  const cols = columnIndexes(header, ["状态", "需求"]);
+  const counts = Object.fromEntries(requirementStatuses.map((status) => [status, 0]));
+  for (const cells of rows) {
+    const status = cols["状态"] >= 0 ? (cells[cols["状态"]] || "").trim() : "";
+    if (Object.prototype.hasOwnProperty.call(counts, status)) counts[status] += 1;
+  }
+  const planRows = readIndexRows(root, "plans");
+  const plansWithStatus = planRows.filter((cells) => validStatuses.includes((cells[2] || "").trim()));
+  const plansDone = plansWithStatus.filter((cells) => (cells[2] || "").trim() === "done");
+  const learningIndex = path.join(root, ".copilot", "LEARNING_INDEX.md");
+  const learningTable = fs.existsSync(learningIndex) ? readMarkdownTable(learningIndex) : { header: [], rows: [] };
+  const cardCols = columnIndexes(learningTable.header, ["Card", "Confidence"]);
+  const candidates = learningTable.rows
+    .map((cells) => ({
+      name: ((cells[cardCols.Card] || "").match(/\[([^\]]+)\]/) || [])[1] || "",
+      confidence: Number((cells[cardCols.Confidence] || "").trim())
+    }))
+    .filter((card) => card.name && Number.isFinite(card.confidence) && card.confidence >= promotionConfidence);
+
+  return {
+    requirements: { total: rows.length, counts },
+    plans: { withStatus: plansWithStatus.length, done: plansDone.length },
+    features: readIndexRows(root, "features").length,
+    candidates
+  };
+}
+
+/** Run the read-only loop report: requirement counts, plan landing rate, feature rows, promotion candidates. */
+function runLoopReport(json) {
+  const summary = summarizeLoop(path.resolve(__dirname, ".."));
+  const counts = summary.requirements.counts;
+  const landingRate = summary.plans.withStatus
+    ? Math.round((summary.plans.done / summary.plans.withStatus) * 100)
+    : 0;
+  if (json) {
+    console.log(JSON.stringify({ checker: "devflow-loop", ...summary, landingRate, judgment: "PASS" }));
+    return 0;
+  }
+  console.log("DevFlow loop report");
+  console.log(`Requirements: total ${summary.requirements.total} | ${requirementStatuses.map((status) => `${status} ${counts[status]}`).join(" | ")}`);
+  console.log(`Plan landing: ${summary.plans.done}/${summary.plans.withStatus} with status (${landingRate}%)`);
+  console.log(`Feature rows: ${summary.features}`);
+  console.log(`Promotion candidates (confidence >= ${promotionConfidence}): ${summary.candidates.length}`);
+  for (const card of summary.candidates) console.log(`  - ${card.name} (${card.confidence})`);
+  console.log("Judgment: PASS");
+  return 0;
+}
+
+/** Dispatch the v2 and legacy plan contracts so old plans keep validating. */
 function checkPlan(body) {
+  return detectV2(body) ? checkPlanV2(body) : checkPlanLegacy(body);
+}
+
+/** Validate global plan headers and all independently scoped task contracts. */
+function checkPlanLegacy(body) {
   const fileStructure = checkFileStructure(body);
   const tasks = splitTasks(body);
   const requiresFileStructure = tasks.some((task) => fieldBlock(task.body, "Task type") === "Code change");
@@ -366,12 +750,21 @@ function report(body, filePath, json) {
     console.log(
       JSON.stringify({
         checker: "plan",
+        format: result.v2 ? "v2" : "legacy",
         landing: landing.message,
         status: result.status,
         invalidStatus: result.invalidStatus,
         missingGlobal: result.missingGlobal,
-        globalUnresolved: result.globalUnresolved,
-        fileStructure: result.fileStructure.ok ? "ok" : "missing or invalid",
+        globalUnresolved: result.globalUnresolved || [],
+        fileStructure: result.v2 ? "v2" : result.fileStructure.ok ? "ok" : "missing or invalid",
+        cut: result.v2 ? { missingRejected: result.cut.missingRejected } : null,
+        progress: result.v2
+          ? {
+              count: result.progress.count,
+              mismatch: result.progress.mismatch,
+              missingEvidence: result.progress.missingEvidence.length
+            }
+          : null,
         tasks: result.tasks.map((task) => ({ number: task.number, ok: task.ok })),
         judgment
       })
@@ -381,22 +774,43 @@ function report(body, filePath, json) {
 
   console.log("DevFlow plan pack report");
   console.log(landing.message);
+  console.log(`Format: ${result.v2 ? "v2" : "legacy"}`);
   console.log(`Status: ${result.invalidStatus ? "invalid" : result.status}`);
-  for (const field of requiredGlobalFields) console.log(`${field}: ${result.missingGlobal.includes(field) ? "missing" : "ok"}`);
-  console.log(`Global unresolved markers: ${result.globalUnresolved.join(", ") || "none"}`);
-  console.log(
-    `File Structure: ${
-      !result.requiresFileStructure ? "documentation-only exception" : result.fileStructure.ok ? "ok" : "missing or invalid"
-    }`
-  );
-  if (result.requiresFileStructure && !result.fileStructure.ok) {
-    console.log(`File Structure invalid rows: ${result.fileStructure.invalidRows.join("; ") || "none"}`);
+  for (const field of result.v2 ? v2GlobalFields : requiredGlobalFields) {
+    console.log(`${field}: ${result.missingGlobal.includes(field) ? "missing" : "ok"}`);
+  }
+  if (result.v2) {
+    console.log(`Cut Rejected: ${result.cut.missingRejected ? "missing" : "ok"}`);
+    console.log(`Progress rows: ${result.progress.count} (tasks ${result.tasks.length})${result.progress.mismatch ? " mismatch" : ""}`);
+    for (const row of result.progress.missingEvidence) console.log(`Progress row ${row.number} is done without evidence`);
+    if (result.doneStatusNeedsAllDone) console.log("Status done requires every Progress row done");
+  } else {
+    console.log(`Global unresolved markers: ${result.globalUnresolved.join(", ") || "none"}`);
+    console.log(
+      `File Structure: ${
+        !result.requiresFileStructure ? "documentation-only exception" : result.fileStructure.ok ? "ok" : "missing or invalid"
+      }`
+    );
+    if (result.requiresFileStructure && !result.fileStructure.ok) {
+      console.log(`File Structure invalid rows: ${result.fileStructure.invalidRows.join("; ") || "none"}`);
+    }
   }
   console.log(`Tasks: ${result.tasks.length}`);
   if (result.tasks.length === 0) console.log("Missing: at least one Task field");
 
   for (const task of result.tasks) {
-    const issues = [
+    const issues = result.v2
+      ? [
+          ...task.missing.map((field) => `missing ${field}`),
+          ...task.unresolved.map((match) => `unresolved ${match}`),
+          ...task.vague.map((match) => `vague ${match}`),
+          ...task.invalidFiles.map((line) => `unclassified file ${line}`),
+          ...task.unlocatedCodeFiles.map((line) => `missing file symbol/anchor ${line}`),
+          ...(task.missingChange ? ["Change needs an executable intent verb"] : []),
+          ...(task.missingNotDoing ? ["missing Not doing exclusion"] : []),
+          ...(task.incompleteVerification ? ["Verify needs command/scenario and expected result"] : [])
+        ]
+      : [
       ...task.missing.map((field) => `missing ${field}`),
       ...task.unresolved.map((match) => `unresolved ${match}`),
       ...task.vague.map((match) => `vague ${match}`),
@@ -621,8 +1035,61 @@ function selfTest() {
   if (!checkPlanLanding("docs/plans/2026-07-14-add-plan-scanner.md").ok) throw new Error("Self-test expected docs/plans landing to pass");
   if (checkPlanLanding("docs/features/add-plan-scanner.md").ok) throw new Error("Self-test expected docs/features plan landing to fail");
 
+  const validV2Plan = [
+    "Status: approved",
+    "Goal: validate the slim v2 plan contract",
+    "Not doing: architecture review",
+    "Cut: 做 checker | 不做 迁移旧计划 | 复用 既有 self-test | 验证 node scripts/devflow-plan.js | Rejected: 新增独立脚本 — 复用既有 checker",
+    "## Tasks",
+    "",
+    "Task: Add v2 validation",
+    "Files:",
+    "- Modify: scripts/devflow-plan.js | symbol: `checkPlanV2` | validate the slim contract",
+    "Change: add v2 field validation and dispatch",
+    "Acceptance: v2 plans pass and legacy plans keep passing",
+    "Verify: run `node scripts/devflow-plan.js --self-test` expect exit 0",
+    "Not doing: changing legacy validation",
+    "",
+    "## Progress",
+    "",
+    "| # | Task | Status | Evidence |",
+    "|---|---|---|---|",
+    "| 1 | Add v2 validation | todo | - |"
+  ].join("\n");
+  if (!detectV2(validV2Plan)) throw new Error("Self-test expected v2 detection to pass");
+  if (!checkPlan(validV2Plan).ok) throw new Error("Self-test expected valid v2 plan to pass");
+  if (checkPlan(validV2Plan.replace(/Rejected:[^\n]*/, "Rejected:")).ok) throw new Error("Self-test expected missing Rejected to fail");
+  if (checkPlan(validV2Plan.replace("| 1 | Add v2 validation | todo | - |", "| 1 | Add v2 validation | done | - |")).ok) {
+    throw new Error("Self-test expected a done Progress row without evidence to fail");
+  }
+  if (checkPlan(validV2Plan.replace("| 1 | Add v2 validation | todo | - |", "")).ok) {
+    throw new Error("Self-test expected a Progress/task count mismatch to fail");
+  }
+  if (typeof checkIndexes !== "function") throw new Error("Self-test expected the index checker to exist");
+  if (matchIndexRows([["功能A", "计划相关", "x"]], "计划").length !== 1) throw new Error("Self-test expected index query to match a row");
+  if (matchIndexRows([["功能A", "计划相关", "x"]], "不存在").length !== 0) throw new Error("Self-test expected index query to miss");
+  if (matchIndexRows([["功能A"]], "").length !== 0) throw new Error("Self-test expected an empty index query to match nothing");
+  if (argValue(["--index", "--query", "计划"], "--query") !== "计划") throw new Error("Self-test expected --query to read its value");
+  if (argValue(["--index", "--query", "--json"], "--query") !== "") throw new Error("Self-test expected --query to reject a flag as its value");
+
+  const requirementHeader = ["日期", "需求", "来源", "深度", "落地物", "状态", "证据或跳过", "更新日"];
+  const requirementRows = [
+    ["2026-09-10", "已落地需求", "用户请求", "A", "docs/specs/x.md", "landed", "npm test 通过", "2026-09-10"],
+    ["2026-09-10", "跳过文档需求", "用户请求", "C", "-", "opt-out", "原因：用户显式跳过", "2026-09-10"]
+  ];
+  const requirementProblems = checkRequirementTable(requirementHeader, requirementRows, () => true);
+  if (requirementProblems.length !== 0) throw new Error(`Self-test expected a valid requirement table to pass: ${requirementProblems.join("; ")}`);
+  const badStatus = checkRequirementTable(requirementHeader, [["2026-09-10", "状态非法", "用户请求", "A", "-", "shipped", "证据", "2026-09-10"]], () => true);
+  if (badStatus.length === 0) throw new Error("Self-test expected an invalid requirement status to fail");
+  const missingEvidence = checkRequirementTable(requirementHeader, [["2026-09-10", "终态无证据", "用户请求", "A", "-", "landed", "-", "2026-09-10"]], () => true);
+  if (missingEvidence.length === 0) throw new Error("Self-test expected a terminal requirement without evidence to fail");
+  const missingReason = checkRequirementTable(requirementHeader, [["2026-09-10", "跳过无原因", "用户请求", "C", "-", "opt-out", "验证通过", "2026-09-10"]], () => true);
+  if (missingReason.length === 0) throw new Error("Self-test expected an opt-out without a reason to fail");
+  const missingArtifact = checkRequirementTable(requirementHeader, [["2026-09-10", "落地物不存在", "用户请求", "A", "docs/specs/nope.md", "planned", "-", "2026-09-10"]], () => false);
+  if (missingArtifact.length === 0) throw new Error("Self-test expected a missing requirement artifact to fail");
+
   console.log("DevFlow plan self-test passed");
-  console.log("Checked code-level fields, precise file locations, mechanics evidence, verification expectations, Read-basis/Live anchors handoff facts, documentation-only exception, external-skill declaration, and plan landing guidance");
+  console.log("Checked v2 and legacy plan contracts, Progress evidence, Cut Rejected, code-level fields, precise file locations, verification expectations, documentation-only exception, external-skill declaration, and plan landing guidance");
 }
 
 const args = process.argv.slice(2);
@@ -634,5 +1101,11 @@ if (args.includes("--self-test")) {
   selfTest();
   process.exit(0);
 }
+if (args.includes("--loop")) {
+  process.exit(runLoopReport(args.includes("--json")));
+}
+if (args.includes("--index")) {
+  process.exit(runIndexCheck(args.includes("--json"), argValue(args, "--query")));
+}
 const targetArg = args.find((arg) => !arg.startsWith("-"));
 process.exitCode = report(readInput(args), targetArg, args.includes("--json"));

package/assets/skills/devflow-brainstorm/SKILL.md

@@ -122,6 +122,8 @@ Confirmed request:
 
 The summary records the agreed request and the exploration findings only. It must not contain an implementation plan, solution-space design, lifecycle route, or handoff instruction. It is the factual basis that downstream skills — starting with `devflow-spec` — build on, so record findings faithfully rather than trimming them away.
 
+On `Status: clarified`, create or update the requirement row in `docs/requirements.md` with status `open`; depth is recorded when the lifecycle path is chosen. Pure Q&A, lookup, and read-only verification create no row.
+
 ## A/B/C Gate
 
 After the fixed summary, present these choices and wait for one explicit user selection:

package/assets/skills/devflow-build/SKILL.md

@@ -19,7 +19,7 @@ When no plan file exists, the approved design and Cut Decision form the Build Co
 
 Load `skills/devflow-build/references/build-methods.md` after this section and before implementation slices. It owns the detailed minimal-change and slice discipline.
 
-There is no broad pre-edit plan review. The executor reads only the current task's execution spec — `Files`, `Change mechanics`, `Steps`, `Verify` — and must reread the current task's named anchors. A current task anchor plus a directly changed neighbor may be reread only when that neighbor is already listed in the task `Files` and its contract could invalidate the edit. An actual edit, anchor mismatch, or verification failure must stop and return `BUILD_BLOCKED` with facts to `devflow-core`: observed mismatch, affected anchor, and smallest replan decision. Do not broadly rediscover, guess, silently repair the plan, or expand scope.
+There is no broad pre-edit plan review. The executor reads the current task's `Files`, `Change`, `Acceptance`, `Verify`, and `Not doing`, and may read the task's named anchors plus one directly changed neighbor to choose the smallest implementation. Build owns how inside the task boundary; it must not broadly rediscover the repository, redesign outside the task boundary, silently repair the plan, or expand scope. An anchor mismatch or verification failure must stop and return `BUILD_BLOCKED` with facts to `devflow-core`: observed mismatch, affected anchor, and smallest replan decision.
 
 Every skill declared in `External Skills` (Cut Decision or plan header) must actually be loaded through the platform's skill mechanism, or the reason it does not apply recorded; loading alone is not completion — Build requires the specialist's returned result, not-applicable, or failure facts. A specialist result implying structure outside the approved scope returns scope-drift facts to `devflow-core`, not silent adoption. Skill loading is not a pre-edit view and remains mandatory.
 
@@ -44,9 +44,11 @@ If work touches more than one file or one logical step, create Implementation Sl
 
 When saving a plan file, use `docs/plans/YYYY-MM-DD-<short-kebab-name>.md`, resolved from the current target project's root, unless that project already documents another plan/spec path. Do not save implementation plans under `docs/features/`; that directory is for feature ledgers.
 
-For multi-step work, tasks must cite the approved source, be small and verifiable, and follow the required task contract (Task: / Task type: / Files: / Interfaces: / Current behavior: / Target behavior: / Change mechanics: / Call impact: / Steps: / Acceptance: / Verify: / Comments: / Not doing:) defined in `skills/devflow-plan/SKILL.md`.
+For multi-step work, tasks must cite the approved source, be small and verifiable, and follow the six-field contract (`Task` / `Files` / `Change` / `Acceptance` / `Verify` / `Not doing`) in `skills/devflow-plan/SKILL.md`. Legacy plans with `Change mechanics` and `Prewalk` stay executable under their own contract.
 
-No unresolved markers. For `Code change`, the dispatched execution spec follows the recorded file symbol/anchor and `Change mechanics`; do not re-decide the implementation mechanism in Build. `Current behavior`, `Target behavior`, and `Call impact` are the plan author's records; bounded current-anchor/neighbor reread is allowed only for drift detection. The verification step must retain its trigger/input, expected result, and command or manual scenario. `Documentation-only` applies only to tasks with no runtime code files and explicit `documentation-only` interfaces. No "add tests" without naming the behavior. No "handle edge cases" without naming the edge case. No "similar to Task N" shortcuts; repeat enough detail for each task to stand alone.
+No unresolved markers. `Change` states the executable intent and boundary; add exact mechanics only when the change crosses a module contract, is irreversible, or touches security or data boundaries. Otherwise Build chooses the smallest implementation and records it as Progress evidence. The verification step keeps its trigger/input, expected result, and command or manual scenario. A task whose files are all documentation paths is documentation-only. No "add tests" without naming the behavior, no "handle edge cases" without naming the edge case, no "similar to Task N" shortcuts.
+
+Close each task by writing back its `## Progress` row: `doing` when starting, `done` with the command and key result when its `Verify` passes. A `done` row without evidence fails the checker. On a legacy plan without a Progress table, report the same evidence in the completion message. When every task is `done`, advance the requirement row in `docs/requirements.md` to `built`.
 
 Before Build, run `node scripts/devflow-plan.js <plan-file>` when a plan is saved to a file. If not found at `scripts/devflow-plan.js` (project-level), try `~/.codex/scripts/devflow-plan.js` or `~/.claude/scripts/devflow-plan.js` (user-level). Do NOT look under `skills/scripts/`. See `core-methods.md` Script Path Resolution.
 
@@ -191,7 +193,7 @@ If any file has no goal link, remove that change.
 | "We'll verify everything at the end." | Verify slices when focused checks exist. |
 | "Docs changes do not need proof." | Docs/rules/skills need validation just like code. |
 | "The issue only mentions one caller." | Check sibling callers before choosing the fix location. |
-| "The plan is approved, so I just execute." | Right: the approved execution spec is edited directly; an actual edit or verification failure returns `BUILD_BLOCKED` to Core. |
+| "The plan is approved, so I just execute." | The plan fixes the boundary and proof; Build still chooses the smallest implementation inside that boundary. A real edit or verification failure returns `BUILD_BLOCKED` to Core. |
 | "I'll infer the missing step." | Guessing past a gap is forbidden; unclear instructions return `BUILD_BLOCKED` facts. |
 | "The code is self-explanatory." | That does not waive a comment required by the approved contract, project convention, or a non-obvious boundary. |
 | "Comments will get stale." | Keep a required comment accurate or remove a stale one; a stale explanation is not a reason to skip a needed decision record. |

package/assets/skills/devflow-build/references/build-methods.md

@@ -19,6 +19,10 @@ Verification:
 
 Split multi-step work into one to five testable slices. Each slice names files, user-visible or contract behavior, verification, and comment requirements. Verify a slice before moving on whenever a focused check exists.
 
+Build owns how. A v2 plan task gives `Files`, `Change`, `Acceptance`, `Verify`, and `Not doing`; the executor reads the named anchors plus one directly changed neighbor, chooses the smallest implementation inside that boundary, and records the choice in the task's `## Progress` evidence. It does not wait for Plan to pre-decide the edit, and it does not widen the boundary. Legacy plans that prescribe `Change mechanics` are followed as written.
+
+After a slice passes its verification, write back the plan's `## Progress` row: `doing` while in flight, `done` with the command and key result when verified. On a legacy plan without a Progress table, report the same evidence in the completion message.
+
 ## Readability Outcome Check
 
 Before handoff, review changed code from the perspective of a maintainer familiar with the project but not this change. Use names, structure, extraction, comments, and tests as appropriate; do not apply any technique mechanically.

package/assets/skills/devflow-core/SKILL.md

@@ -15,6 +15,7 @@ Trigger: <user words or task shape>
 Route: Problem / Fast / Design-lite / Design / Build / Recovery
 Brainstorm required: yes/no
 Depth hint: skip / compact / standard / deep / none
+Preferences applied: <count of global preference cards matched this turn>
 Next skill: <skill name or none>
 Status: [DevFlow: <node> -> <next> | awaiting approval / in progress]
 ```
@@ -25,7 +26,7 @@ While a DevFlow lifecycle node is active, end each user-facing message with one
 
 Read `skills/devflow-core/references/core-methods.md` before route selection. It supplies Method 0, shared route rules, and the owner map. Do not load all lifecycle references by default.
 
-Read the narrowest relevant project facts, then progressively recall learning and project knowledge. Scan available skills and record a matching external specialist skill; a specialist may perform bounded specialist work inside the current node while DevFlow retains route and node ownership.
+Read the narrowest relevant project facts, then match the task keywords against `docs/features/INDEX.md` and `docs/plans/INDEX.md` when present and open only the matched row's entry file or ledger section; an index over 40 rows is filtered with `node scripts/devflow-plan.js --index --query 关键词`. Do not bulk-read capability documents. Then progressively recall learning and project knowledge. Scan available skills and record a matching external specialist skill; a specialist may perform bounded specialist work inside the current node while DevFlow retains route and node ownership.
 
 Before a route-specific decision, load only the selected owner reference:
 
@@ -61,6 +62,8 @@ Brainstorm is required when any material risk or decision-impact uncertainty exi
 | Build | User asks to implement, fix, build, or land an approved change. | Select Cut, then Plan when construction needs several steps, then Build and Prove. |
 | Recovery | Same target remains wrong after correction or proof failure. | Select PUA, consume recovery facts, then choose a different path. |
 
+Every creative or problem-directed change creates or updates one row in `docs/requirements.md`: Brainstorm writes `open` after `Confirmed request`, and Design-lite writes `open` with depth `C` when Brainstorm is skipped. Pure Q&A, lookup, read-only verification, and explicit independent reviews create no row.
+
 ## Core Flow Map
 
 ```text

package/assets/skills/devflow-core/references/core-methods.md

@@ -35,10 +35,11 @@ Apply these principles to every route:
 Read the narrowest useful facts:
 
 1. Project rules and relevant source, tests, commands, and current docs.
-2. `.copilot/LEARNING_INDEX.md`, then only cards whose Trigger and Scope match.
-3. `docs/project-knowledge/AI-START-HERE.md` or `index.md`, then only navigation-selected documents.
-4. `graphify-out/GRAPH_REPORT.md` when architecture impact is in scope.
-5. Available environment skills; record a matching specialist skill without widening DevFlow scope. For a matched specialist, record the bounded-work contract:
+2. `docs/features/INDEX.md` and `docs/plans/INDEX.md` when present: match the task keywords against the index rows and read only the matched row's entry file or ledger section; an index over 40 rows is filtered with `node scripts/devflow-plan.js --index --query 关键词`. Do not bulk-read capability documents. Missing indexes are non-blocking.
+3. `.copilot/LEARNING_INDEX.md`: match `Scope: global` preference cards first (few, cross-project), then `project` cards whose Trigger and Scope match. Apply known preferences and report the count in Activation Evidence.
+4. `docs/project-knowledge/AI-START-HERE.md` or `index.md`, then only navigation-selected documents.
+5. `graphify-out/GRAPH_REPORT.md` when architecture impact is in scope.
+6. Available environment skills; record a matching specialist skill without widening DevFlow scope. For a matched specialist, record the bounded-work contract:
 
 ```text
 Owner: current DevFlow node

package/assets/skills/devflow-cut/SKILL.md

@@ -167,6 +167,14 @@ CUT_REUSE: existing capability can be reused; do not write new implementation
 CUT_BLOCKED: missing facts or risk too high; return the blocking facts to `devflow-core`
 ```
 
+Every result also records a four-line decision plus a mandatory subtraction record:
+
+```text
+Cut: 做 <what is included> | 不做 <what is excluded> | 复用 <reused capability> | 验证 <verification> | Rejected: <at least one candidate scope, dependency, abstraction, or config that was cut, or none plus evidence why nothing could be cut>
+```
+
+`Rejected` is what separates a real Cut from a rubber stamp. A Cut that removes nothing writes `Rejected: none` and names the evidence that ruled each candidate out; a Cut that removes something names it. Without this line, a plan can pass every gate while quietly carrying avoidable work.
+
 When `CUT_REDUCE` or `CUT_REUSE` occurs, **STOP — present the reduction or reuse finding to the user**. Explain what was cut, what existing capability replaces it, and why the smaller option is sufficient. After confirmation, return the confirmed result to `devflow-core`.
 
 When `CUT_BLOCKED` occurs, return the blocking facts to `devflow-core`. Core decides whether it must restart `devflow-brainstorm` to re-explore the goal and constraints.
@@ -195,7 +203,7 @@ When `CUT_BLOCKED` occurs, return the blocking facts to `devflow-core`. Core dec
 
 ## Handoff
 
-After `CUT_PASS`, record a Cut Decision containing the allowed scope, reuse conclusion, exclusions, required verification, `External Skills`, and `Depth`. A recorded specialist role performs bounded work only; Cut retains reuse and scope authority, and `CUT_PASS` is never delegated. A/B directly enter `devflow-plan`; C directly enters `devflow-build`. `CUT_REDUCE`, `CUT_REUSE`, and `CUT_BLOCKED` return facts to `devflow-core`; `CUT_REDUCE` and `CUT_REUSE` remain stopped until user confirmation. A Plan Pack that broadens scope returns affected-gate facts to Core before any later selection.
+After `CUT_PASS`, record a Cut Decision containing the four-line decision, the `Rejected` subtraction record, allowed scope, reuse conclusion, exclusions, required verification, `External Skills`, and `Depth`. When a plan file is produced, the four lines and `Rejected` go into the plan header; at depth C they stay in the Build Contract message. A recorded specialist role performs bounded work only; Cut retains reuse and scope authority, and `CUT_PASS` is never delegated. A/B directly enter `devflow-plan`; C directly enters `devflow-build`. `CUT_REDUCE`, `CUT_REUSE`, and `CUT_BLOCKED` return facts to `devflow-core`; `CUT_REDUCE` and `CUT_REUSE` remain stopped until user confirmation. A Plan Pack that broadens scope returns affected-gate facts to Core before any later selection.
 
 ## Verification
 
@@ -204,5 +212,6 @@ Before leaving this skill, confirm:
 - [ ] Reuse, Root-Cause when relevant, Native, Overbuild, Diff, and Scope checks were answered.
 - [ ] Any new structure has a current need.
 - [ ] Removed scope is explicitly named.
+- [ ] The four-line `Cut` decision is recorded, with a non-empty `Rejected` or `none` plus evidence.
 - [ ] Intentional simplifications have `devflow:` ceiling and revisit trigger markers.
 - [ ] Cut result is one of the four allowed statuses.

package/assets/skills/devflow-cut/references/cut-methods.md

@@ -40,8 +40,11 @@ Reuse Check: what existing capability was checked first?
 Trace Check: what accepted request does each key change trace to?
 Scope Check: what tempting but unrequested feature was removed?
 Diff Check: which user goal does each changed file serve?
+Rejected: what candidate scope, dependency, abstraction, or config was cut — or none plus the evidence that ruled each candidate out?
 ```
 
+`Rejected` is not optional. A gate that answers only "what is included" cannot show whether any subtraction happened, which is how a Cut degrades into a stamp. Name the cut candidate, or name the evidence that closed each candidate out.
+
 ## Method 8A: Contextual Design Quality Check
 
 For changes that introduce or relocate code, alter module responsibilities, or add performance behavior, inspect the nearest comparable project code before selecting a shape. Record the decision without requiring a fixed layer, class count, interface, or cache:

package/assets/skills/devflow-docs-followup/SKILL.md

@@ -34,7 +34,7 @@ Rules:
 
 - Treat only an explicit selection as approval to create that document type.
 - Treat silence, an ambiguous reply, or an unselected item as not approved.
-- Treat `none` as a completed follow-up with no files written.
+- Treat `none` as a completed follow-up with no files written; record it as `opt-out` in `docs/requirements.md` with the skip reason and the verification evidence. Silence or an ambiguous reply never becomes `opt-out`; the default requirement record still applies.
 - If the user selects more than one type, create only those selected types.
 
 ## Evidence And Landing

package/assets/skills/devflow-learn/SKILL.md

@@ -19,15 +19,21 @@ Extract only knowledge that can help a future task:
 - a non-obvious repository convention or invariant
 - a costly, counterintuitive, repeated, or project-wide lesson
 - a confirmed project-business fact that may require knowledge-package maintenance
+- a user-visible capability or interface-contract change that must appear in `docs/features/INDEX.md`
+- a developer preference about how to work — language, documentation depth, design-first, verify-command habits, review style — confirmed by a repeated correction
 
 `PASS` requires the review, not a new record. If no useful reusable knowledge remains after classification, report that result and create nothing.
 
 | Review result | Action | Store |
 |---|---|---|
 | Reusable execution experience or proven work pattern | Create or update one focused card | `.copilot/cards/` |
+| User-visible capability or interface contract changed | Add or update one row: what it does, its trigger words, its entry point, its verify command, and its source plan | `docs/features/INDEX.md` |
+| The same how-to preference was corrected twice | Create or update one `Scope: global` preference card | `.copilot/cards/` |
 | Confirmed business fact changed | Report a project-knowledge candidate and wait for user confirmation | `docs/project-knowledge/` after confirmation via `devflow-project-knowledge` |
 | Ordinary detail, one-off fact, already-covered lesson, or pure refactor without insight | Report no useful record | none |
 
+The capability row is a mechanical duty, not a documentation inquiry: a verified change that alters what a user can do, or an interface contract others depend on, must be findable from one index on the next session. Writing a longer document still needs explicit user confirmation through `devflow-docs-followup`.
+
 Project-knowledge candidates include changed domain semantics, rules, boundaries, entity/DTO/enum meaning, API or table boundaries, module responsibility, job behavior, and task entry points. `devflow-learn` must not update the package itself or infer business facts without evidence.
 
 ## Process
@@ -39,6 +45,7 @@ Project-knowledge candidates include changed domain semantics, rules, boundaries
 4. Extract a candidate from the task's implementation, decisions, proof, and business impact.
 5. Decide whether to record:
    - record if the candidate is cross-task reusable and proven useful, costly if missed, counterintuitive, non-obvious, repeated, or project-wide
+   - add or update one capability row in `docs/features/INDEX.md` with trigger words if the verified change altered user-visible behavior or an interface contract; report `no-change` otherwise
    - report a project-knowledge candidate if code-backed business semantics changed; wait for user confirmation before calling `devflow-project-knowledge`
    - skip if it is ordinary narration, a one-off fact, already covered, or too context-specific
 6. Create `.copilot/LEARNING_INDEX.md`, `.copilot/cards/`, and one focused card only when the result belongs in project learning; do not create empty learning storage after a no-record review.
@@ -96,9 +103,10 @@ Learning storage is lazily created only by this skill after a qualifying reusabl
 |---|---|---|
 | `graphify-out/` | Structural code graph, communities, and dependency relationships | Execution lessons or curated business guidance |
 | `.copilot/cards/` | Execution experience, intercept rules, and proven work patterns | Business reference documentation |
+| `docs/features/INDEX.md` | The capability routing index: what a feature does, its trigger words, its entry point, its verify command, and its source plan | Execution lessons, business reference docs, version history, feature bodies |
 | `docs/project-knowledge/` | Curated, code-backed business facts, boundaries, and task entry points | Agent mistakes or raw implementation history |
 
-Handoff: `devflow-prove PASS` -> `devflow-learn` review -> project-knowledge candidate -> user confirmation -> `devflow-project-knowledge` lazy maintenance of `docs/project-knowledge/`. Only after a verified feature implementation with an actual source-behavior or interface-contract change may `devflow-learn` hand off to `devflow-docs-followup` for an optional documentation inquiry. Do not automatically hand off validation-only, documentation-only, rule-only, skill-only, or no-diff `PASS` results.
+Handoff: `devflow-prove PASS` -> `devflow-learn` review -> capability row in `docs/features/INDEX.md` and/or a project-knowledge candidate -> user confirmation -> `devflow-project-knowledge` lazy maintenance of `docs/project-knowledge/`. Only after a verified feature implementation with an actual source-behavior or interface-contract change may `devflow-learn` hand off to `devflow-docs-followup` for an optional documentation inquiry. Do not automatically hand off validation-only, documentation-only, rule-only, skill-only, or no-diff `PASS` results.
 
 ## Card Format
 
@@ -133,6 +141,7 @@ Read this index first. Only read a card when its trigger matches the current tas
 | 1 | Create/update card, confidence 0.3-0.5 |
 | 2 | Raise confidence and force recall before acting |
 | 3 | Propose `AGENTS.md` or platform rule update |
+| Card confidence reaches 0.7 | Propose the rule or skill change and create one `docs/requirements.md` row for the proposal, so learning returns to the requirement loop |
 | 4+ | Propose skill or command automation |
 | User explicitly says remember/learn/沉淀 | Promote immediately if scope is clear |
 
@@ -145,7 +154,8 @@ Learning closure:
 - Learning signal: PASS review/correction/pitfall/none
 - Recall record: none/index/card
 - Knowledge recall: none/learning index + matched card/project knowledge candidate
-- Review result: learning card/project-knowledge candidate/no useful record
+- Review result: learning card/capability row/project-knowledge candidate/no useful record
+- Capability entry: added/updated/no-change
 - New sediment: none/learning card/rule/skill
 - Next intercept: next time <X>, first do <Y>, do not do <Z>
 ```
@@ -172,5 +182,6 @@ Before leaving this skill, confirm:
 - [ ] Only matched cards were read.
 - [ ] Repeated user corrections, repeated user challenges, and misplaced content were recorded or explicitly classified as already covered.
 - [ ] New or updated card has trigger, lesson, next action, scope, related files, evidence, and invalidation condition.
+- [ ] A user-visible capability or interface-contract change added or updated one `docs/features/INDEX.md` row with trigger words, or was reported as `no-change`.
 - [ ] Business-semantic changes were reported as candidates and await user confirmation before knowledge-package maintenance.
 - [ ] Completion output includes learning closure.

package/assets/skills/devflow-plan/SKILL.md

@@ -16,13 +16,14 @@ Turn an A/B `CUT_PASS`-bounded approved design or confirmed Spec into one review
 ## Authoring Process
 
 1. Read only source material, code, tests, and conventions relevant to the approved scope. Load `skills/devflow-spec/references/spec-plan-methods.md` and `skills/devflow-plan/references/plan-methods.md` before applying Plan Pack mechanics.
-2. Map exact affected file responsibilities once in `## File Structure` before writing tasks. Reuse existing modules and name the intended file operation.
-3. Perform bounded real investigation and record it as task-level `Prewalk`: actual `Execution Trace`, Current Handoff Facts, and only the unfinished `Remaining Structured Worklist`.
-4. Split independent deliverables into small, reviewable tasks. Each task should be understandable without referring to another task, and it carries its own complete execution spec（执行规范）— `Files`, `Change mechanics`, `Steps`, and `Verify` — so the executor can edit directly while still re-reading the current task anchor. A directly changed neighbor is reread only when it is already listed and its contract could invalidate the edit.
-5. Write the plan using the required header and task contract below.
-6. Self-review Cut Decision fidelity, source coverage, File Structure, Prewalk evidence, file-operation classifications, interface consistency, concrete steps, acceptance proof, and scope exclusions.
+2. Map the intended touch set once: list the files and the responsibility each one carries. Reuse existing modules and name the intended file operation.
+3. Do the bounded investigation needed to write correct tasks. Keep that evidence in the conversation or in a learning card; it is not a plan field.
+4. Split independent deliverables into small, reviewable tasks. Each task carries `Files`, `Change`, `Acceptance`, `Verify`, and `Not doing` so an executor can act on it without reading another task.
+5. Write the plan using the required header, task contract, and `## Progress` table below.
+6. Self-review Cut fidelity, touch-set coverage, acceptance proof, scope exclusions, and Progress row count against the task count.
 7. Run `node scripts/devflow-plan.js <plan-file>` when the project-level checker exists. Otherwise resolve the user-level checker according to `core-methods.md` Script Path Resolution.
 8. **STOP — request user review.** On DSH, request review with the structured `ask_user_question` tool (single-select: approve / request changes). Revise and revalidate when requested. On approval, ask execution mode (single-select: `sequential` — the Build agent runs tasks in dependency order / `single-subagent` — the main agent only schedules: one subagent runs tasks one per round in dependency order / `fan-out` — independent tasks run as parallel subagents) and record it as the plan's optional `Execution mode` header. Then perform only a lightweight Cut-consistency review. An approved A/B Plan directly enters `devflow-build`; scope-drift facts return to `devflow-core`.
+9. On approval, advance the requirement row in `docs/requirements.md` to `planned` and fill the plan path in its artifact column.
 
 Default landing is `docs/plans/YYYY-MM-DD-<short-kebab-name>.md`, resolved from the target project root. Do not place implementation plans in `docs/features/` or `docs/specs/`.
 
@@ -33,88 +34,64 @@ Structural headers remain English so the checker can parse them; content uses th
 ```text
 # <Plan title>
 
+Status: draft | approved | in-progress | done | abandoned
 Goal: <outcome>
-Architecture: <smallest design and boundaries>
-Tech Stack: <relevant existing stack>
-Source: <approved design or docs/specs/YYYY-MM-DD-<short-kebab-name>.md>
-Spec coverage: <requirements mapped to tasks, or design-only>
-Cut Decision: <CUT_PASS allowed scope, reuse conclusion, exclusions, verification constraints>
-External Skills: <skill-name>; role: <bounded specialist work>; expected evidence: <result needed by that node>; return facts: <result / not-applicable / failure> / none
+Not doing: <scope excluded>
+Cut: 做 <included> | 不做 <excluded> | 复用 <reused capability> | 验证 <verification> | Rejected: <at least one cut candidate, or none plus evidence why nothing could be cut>
+Source: <approved design or docs/specs/YYYY-MM-DD-<short-kebab-name>.md> (optional)
 Execution mode: sequential | single-subagent | fan-out (optional; ask and record at approval)
+Landed: <date and fresh evidence> (completion only)
 
-## Global Constraints
-- <applicable boundary>
+## Tasks
 
-## File Structure
+Task: <short, independently understandable title>
+Files:
+- Create: <path> | new file | <responsibility>
+- Modify: <path> | <symbol or stable anchor> | <responsibility>
+- Test: <path> | <symbol or stable anchor> | <behavior proved>  # only when applicable
+Change: <what changes and its boundary; add the smallest mechanics only when the change crosses a module contract, is irreversible, or touches security or data boundaries>
+Acceptance: <specific observable condition>
+Verify: <exact command or manual scenario, trigger/input, and expected result>
+Not doing: <scope excluded by this task>
+
+## Progress
 
-| File / symbol | Operation | Responsibility | Why here | Not responsible for |
-|---|---|---|---|---|
-| <path and stable anchor> | Create / Modify / Test | <one responsibility> | <placement rationale> | <explicit boundary> |
+| # | Task | Status | Evidence |
+|---|---|---|---|
+| 1 | <task title> | todo | - |
 ```
 
+The v2 header is deliberately slim: the Plan owns ordering and acceptance, while Cut owns the subtraction and Build owns how the change is implemented. `Cut` is one line and must carry a non-empty `Rejected` (or `none` plus evidence), so a plan without a real subtraction is visible instead of silently passing. `## Progress` is the resume and landing record: Build flips one row to `doing` or `done` and fills its evidence, and Prove writes `Landed` on `PASS`. A plan without `## Progress` and with a `Prewalk` block is a legacy plan; `scripts/devflow-plan.js` keeps validating it with the old rules, so existing plans never need migration.
+
 Inherit `External Skills` from the Cut Decision unchanged; the Plan Pack carries the specialist role, expected evidence, and return facts into Build and Prove. When a specialist skill is declared, merge its core quality checks into the affected tasks' `Acceptance` and `Verify` fields — the Plan Pack is the only channel that carries external-skill quality requirements into Build and Prove. A declared skill never widens the Cut scope; if its recommendation exceeds the Cut Decision, return the scope-drift facts to `devflow-core`.
 
 `Execution mode` is not part of Cut scope and does not change the checker. It is asked at approval and recorded so Build knows how to run tasks: sequentially as the Build agent itself, through one delegated subagent while the main agent only schedules, or fan out independent tasks to parallel subagents.
 
-Each task's `Files`, `Change mechanics`, `Steps`, and `Verify` form the execution basis（执行规范）handed to the executor. The executor must re-read the current task's named anchors. A current task anchor and directly changed neighbor may be reread only when that neighbor is already listed and its contract could invalidate the edit; this is a bounded drift check, not broad repository rediscovery. `Read-basis` / `Live anchors` remain the plan author's evidence record. Do not silently repair stale instructions, redesign outside scope, or expand the touch set.
+Each task's `Files`, `Change`, `Acceptance`, `Verify`, and `Not doing` form the execution basis（执行规范）handed to the executor. Build may read the current task's named anchors and a directly changed neighbor to choose the smallest implementation; it must not broadly rediscover the repository, redesign outside the task boundary, silently repair the plan, or expand the touch set. A real anchor mismatch or verification failure returns `BUILD_BLOCKED` facts to `devflow-core` instead of a guessed edit.
 
 ## Required Task Contract
 
 ```text
 Task: <short, independently understandable title>
-Task type: Code change | Documentation-only
 Files:
 - Create: <path> | new file | <responsibility>
 - Modify: <path> | <symbol or stable anchor> | <responsibility>
-- Test: <path> | <test symbol or stable anchor> | <behavior proved>  # only when applicable
-Interfaces:
-- Consumes: <exact symbol/API input and type/shape, or documentation-only exception>
-- Produces: <exact symbol/API output and type/shape, or documentation-only exception>
-Current behavior: <observable current state>  # Code change only
-Target behavior: <observable outcome>  # Code change only
-Change mechanics: <minimal code snippet, pseudocode, or exact replacement rule>  # Code change only
-Call impact: <known callers/downstream effect, or no runtime impact>  # Code change only
-Steps:
-- [ ] <one file + symbol/anchor + executable action; include the relevant snippet, pseudocode, or exact replacement for code logic>
-- [ ] <one verification action with trigger/input, expected result, and command or manual scenario>
+- Test: <path> | <symbol or stable anchor> | <behavior proved>  # only when applicable
+Change: <what changes and its boundary; exact mechanics only when the change crosses a module contract, is irreversible, or touches security or data boundaries>
 Acceptance: <specific observable condition>
 Verify: <exact command or manual scenario, trigger/input, and expected result>
-Comments: <locations and reasons required by Code Documentation, project convention, or non-obvious boundaries; or "none — trivial change">
-Not doing: <scope excluded>
-
-Prewalk:
-
-Execution Trace:
-- Read: <actual file/symbol/range> → <observed fact relevant to this task>.
-- Traced: <actual caller, entry point, collaborator, contract, or test> → <observed path or constraint>.
-- Ran: <actual command or scenario> → <relevant result, including a failure when applicable>.
-- Edited: <actual file/symbol and change> → <reason; or "none yet">.
-- Verified: <actual check> → <observed result; or "none yet">.
-
-Current Handoff Facts:
-- Target anchors: <current file, symbol, or range the plan author verified (evidence record, not executor re-read instruction)>.
-- Nearby convention: <comparable inspected code and observed convention; or "no comparable code found">.
-- Direct path: <traced callers, collaborators, boundaries, affected tests; or "none">.
-- Current constraints: <observed contract, ordering, errors, compatibility; or "none">.
-- Planned touch set: <remaining expected files/symbols and reason>.
-- Risks / stop conditions: <facts requiring Core replan; or "none beyond ordinary Plan drift">.
-
-Remaining Structured Worklist:
-- [ ] <one independently completable remaining action with file/symbol and expected outcome>.
-  Anchors: <minimum current anchors>.
-  Verify: <command, test, call-path check, or observable result>.
-  Done when: <fact proving this action is complete>.
+Not doing: <scope excluded by this task>
 ```
 
-`File Structure` is one responsibility map, not a fixed architecture rule. For every non-trivial Code change, every task must carry a `Prewalk`. Each trace row records an action actually performed and its observed result; it cannot describe planned work. `Remaining Structured Worklist` contains only unfinished actions. Each item needs `Anchors`, `Verify`, and `Done when`; cap one task at 12 items. The executor reads the current task's execution spec, must reread named anchors, may reread at most one already-listed neighbor for drift detection, edits, runs `Verify`, appends actual evidence, and returns observed differences as facts to `devflow-core` when an edit or verification fails. Documentation-only tasks retain their existing exception.
+Use only `Create`, `Modify`, and `Test` file-operation labels. `Create` rows use `new file`; every other row names a symbol or stable anchor. `Change` states the executable intent and its boundary in one or two lines; it does not restate current behavior, target behavior, call impact, or interfaces unless the task changes a cross-module contract. The Plan no longer classifies tasks by `Task type`: a task whose files are all documentation paths is documentation-only, and the checker treats it that way.
 
-Use only `Create`, `Modify`, and `Test` file-operation labels. For a `Code change`, every existing-file row must name a symbol or stable anchor; `Create` rows use `new file`. `Current behavior`, `Target behavior`, `Change mechanics`, and `Call impact` are mandatory. `Change mechanics` must contain the smallest code snippet, pseudocode, or exact replacement rule that removes implementation inference. Interfaces name exact symbols and input/output shape. The verification step and `Verify` field name the trigger/input, expected result, and runnable command or manual scenario.
+Six fields per task is the whole contract: ordering, the touch set, the intent, the acceptance condition, the proof command, and the exclusion. Investigation traces, handoff facts, per-task worklists, architecture, tech stack, spec coverage, and comment locations are owned by other nodes or stay in the conversation. `Prewalk`, `File Structure`, `Interfaces`, `Current behavior`, `Target behavior`, `Change mechanics`, `Call impact`, and `Comments` are not part of the v2 contract; a plan that still carries them is treated as legacy.
 
-`Documentation-only` is allowed only when no runtime code changes. Its `Consumes` and `Produces` entries explicitly say `documentation-only`; it cannot label a task that changes a code file. A task does not need a test file unless a test is needed for its stated behavior. Avoid vague work such as generic test additions, unnamed edge cases, cleanup, or cross-task shorthand.
+Keep one task understandable on its own. Do not use cross-task shorthand, generic test additions, unnamed edge cases, or cleanup entries. Name a test file only when the stated behavior needs one.
 
 ## Boundaries
 
-Plan generation does not repeat Cut, perform Build or Prove, prescribe independent review, test-first workflow, version-control task steps, or execute automatically. It converts `CUT_PASS` into a static construction checklist. The checker validates static structure; it does not judge architecture or lifecycle state. Plan generation writes the execution spec（执行规范）; the zero-view（零 view）execution discipline belongs to `plan-methods.md` and `devflow-build` — a Plan Pack must not include execution-phase re-read or pre-edit review instructions.
+Plan generation does not repeat Cut, perform Build or Prove, prescribe independent review, test-first workflow, version-control task steps, or execute automatically. It converts `CUT_PASS` into a slim construction checklist plus a Progress record. The checker validates static structure; it does not judge architecture or lifecycle state. The v2 contract applies to new plans only; legacy plans keep the old validation rules and are never migrated or rewritten.
 
 ## Anti-Rationalization
 
@@ -131,14 +108,13 @@ Plan generation does not repeat Cut, perform Build or Prove, prescribe independe
 
 Before leaving this skill, confirm:
 
-- [ ] `CUT_PASS` is cited with allowed scope, reuse conclusion, exclusions, and verification constraints.
+- [ ] `Cut` is one line with 做 / 不做 / 复用 / 验证 and a non-empty `Rejected`.
 - [ ] `External Skills` is inherited from the Cut Decision; declared skills' quality checks are merged into task `Acceptance`/`Verify`.
 - [ ] Execution mode was asked at approval and recorded as the optional `Execution mode` header.
-- [ ] Approved design or saved spec is cited as `Source`.
-- [ ] `Spec coverage` maps the source to plan tasks.
-- [ ] Header, constraints, File Structure, interfaces, concrete steps, acceptance, verification, context-specific comments, exclusions, and task-level Prewalk records are present.
-- [ ] Each trace entry is an observed past action/result; each remaining worklist item is bounded, verified, and fact-complete.
-- [ ] Every task is independently understandable, requires named-anchor rereads and at most one already-listed neighbor, and has no unresolved or vague placeholder.
+- [ ] Approved design or saved spec is cited as optional `Source`.
+- [ ] Header, tasks, and `## Progress` match the v2 contract; each task has six fields and no legacy field.
+- [ ] Every task is independently understandable and has no unresolved or vague placeholder.
+- [ ] Progress row count equals task count; every `done` row carries evidence.
 - [ ] The checker passed when available.
 - [ ] The user reviewed the written plan.
 - [ ] An approved A/B Plan entered `devflow-build`; any scope-drift facts returned to `devflow-core`.

package/assets/skills/devflow-plan/references/plan-methods.md

@@ -2,73 +2,51 @@
 
 Use this reference after `skills/devflow-spec/references/spec-plan-methods.md` and before writing a Plan Pack. It defines the smallest handoff that lets another executor continue approved work without repeating broad repository discovery.
 
-## File Structure
+## Touch Set
 
-Write one `## File Structure` table before tasks:
+State the intended touch set once, before tasks: the files and the responsibility each one carries. Reuse the nearest owner when it already has the responsibility. If no target can hold the responsibility without a materially different concern, return the fact to Core instead of inventing a generic abstraction.
 
-```text
-| File / symbol | Operation | Responsibility | Why here | Not responsible for |
-|---|---|---|---|---|
-| [path and stable anchor] | Create / Modify / Test | [one responsibility] | [placement rationale] | [explicit boundary] |
-```
+The v2 Plan Pack has no `File Structure` table. The per-task `Files` rows are the touch set; a global table would only restate them.
 
-The table states where approved responsibility belongs. It does not mandate a class count, layer, pattern, or automatic file split. Reuse the nearest owner when it already has the responsibility. If no target can hold the responsibility without a materially different concern, return the fact to Core rather than inventing a generic abstraction.
+## Task Rows
 
-## Prewalk
-
-Every non-trivial Code change task ends with `Prewalk`. It is an append-only handoff with three parts:
+Each task carries exactly six fields:
 
 ```text
-Prewalk:
-
-Execution Trace:
-- Read: [actual file/symbol/range] → [observed fact].
-- Traced: [actual caller, entry point, collaborator, contract, or test] → [observed path or constraint].
-- Ran: [actual command or scenario] → [relevant result].
-- Edited: [actual file/symbol and change] → [reason; or "none yet"].
-- Verified: [actual check] → [observed result; or "none yet"].
-
-Current Handoff Facts:
-- Target anchors: [current file/symbol/range the plan author verified; evidence record, not executor re-read instruction].
-- Nearby convention: [inspected comparable code and observed convention; or "no comparable code found"].
-- Direct path: [traced callers, collaborators, boundaries, affected tests; or "none"].
-- Current constraints: [observed contract, ordering, error behavior, compatibility; or "none"].
-- Planned touch set: [remaining expected files/symbols and reason].
-- Risks / stop conditions: [facts that require Core replan; or "none beyond ordinary Plan drift"].
-- Read-basis: [已读文件清单——计划作者的证据簿记，执行者不重读].
-- Live anchors: [计划作者已确认的锚点——执行者不重读，仅作失败回报时的定位].
-
-Remaining Structured Worklist:
-- [ ] [one independently completable remaining action with file/symbol and expected outcome].
-  Anchors: [minimum current anchors].
-  Verify: [command, test, call-path check, or observable result].
-  Done when: [fact proving completion].
+Task: <short, independently understandable title>
+Files: <Create / Modify / Test rows with path and symbol or stable anchor>
+Change: <what changes and its boundary>
+Acceptance: <specific observable condition>
+Verify: <command or manual scenario with trigger, input, and expected result>
+Not doing: <scope excluded by this task>
 ```
 
-### Trace Rules
+`Change` states the executable intent. Add exact mechanics only when the change crosses a module contract, is irreversible, or touches security or data boundaries. Otherwise the executor chooses the smallest implementation inside the task boundary. This is the deliberate trade: the plan stops pre-deciding every edit, and Build regains bounded implementation authority. That trade is the fix for the bloated-plan problem, not a relaxation of proof.
+
+Investigation evidence does not belong in the plan. Keep it in the conversation, or in a `.copilot/cards/` learning card when it is reusable across tasks.
 
-- Record only work actually performed and what it observed. Do not write future-tense discovery instructions as trace evidence.
-- `Read`, `Traced`, `Ran`, `Edited`, and `Verified` may say `none yet` only where that action truly has not happened. At least one actual read or trace result is required for a Code change handoff.
-- A failed command is valid evidence when its relevant failure is recorded. Do not rewrite it as success.
-- The executor appends real evidence after completing each remaining work item; it does not erase prior trace facts.
+## Progress Table
 
-### Worklist Rules
+Close the plan with one row per task:
+
+```text
+| # | Task | Status | Evidence |
+|---|---|---|---|
+| 1 | <task title> | todo | - |
+```
 
-- Include only unfinished work. Completed work belongs in `Execution Trace`.
-- Order work by dependency. Keep every item independently verifiable.
-- Require `Anchors`, `Verify`, and `Done when` for each item. Generic phrases such as “check the code” do not prove completion.
-- Limit one task to 12 remaining items. Group mechanical substeps under one verified result or return a scope-splitting fact to Core.
+Status values are `todo`, `doing`, and `done`. Build flips the row it is working on and fills the evidence with the command and key result. Prove writes `Status: done` and `Landed:` on `PASS`. A `done` row without evidence fails the checker, and a plan whose header `Status` is `done` requires every row to be `done`. The table is why an interrupted session can resume: the next reader sees exactly what landed and what did not.
 
-## Delegated Execution
+## Execution Handoff
 
-A delegated executor — the main agent itself, one delegated subagent, or one fan-out subagent — receives only the current task's execution spec (`Files`, exact replacement rules, `Steps`, `Verify`). Before editing, it must re-read the current task's named anchors. A current task anchor and directly changed neighbor may be reread only when that neighbor is already listed and its contract could invalidate the edit; it must not broadly rediscover the repository, re-plan, or expand scope. `Read-basis` and `Live anchors` stay in the plan as the plan author's evidence record. A detected mismatch returns facts to Core instead of silent repair.
+An executor — the main agent itself, one delegated subagent, or one fan-out subagent — receives the current task's six fields. It may read the task's named anchors and one directly changed neighbor to choose the smallest implementation; it must not broadly rediscover the repository, redesign outside the task boundary, silently repair the plan, or expand the touch set.
 
-When an edit cannot be applied or a `Verify` fails, or a bounded reread finds changed authorization/contract behavior, the executor returns the observed difference — affected file/anchor, actual behavior, blocked verification, and smallest replan decision — as facts to `devflow-core`; it does not guess past a mismatch. A stale line reference may be corrected only when the symbol, contract, responsibility, and intended outcome are unchanged.
+When an edit cannot be applied, a `Verify` fails, or a bounded read finds changed contract behavior, the executor returns the observed difference — affected file/anchor, actual behavior, blocked verification, and the smallest replan decision — as facts to `devflow-core`. It never guesses past a mismatch.
 
 ### Fan-out
 
-When the plan's `Execution mode` is `fan-out`, one Build orchestrator partitions tasks into parallel groups and dispatches each task to a subagent. Every subagent receives only its own task's execution spec, must reread named anchors and at most one already-listed neighbor, edits its task's `Files`, runs its task's `Verify`, and returns evidence or failure facts. It does not broadly rediscover or redesign. Two tasks may run in parallel only when their `Files` touch disjoint file/symbol sets and neither `Interfaces` consumes a symbol the other `Produces`; tasks sharing a file/symbol or with a consume/produce dependency run in sequence. The orchestrator merges returned results, reconciles cross-task overlap, and enters Prove once with merged evidence.
+When the plan's `Execution mode` is `fan-out`, one Build orchestrator partitions tasks into parallel groups and dispatches each task to a subagent. Every subagent receives only its own task's six fields, reads its anchors, edits its task's `Files`, runs its task's `Verify`, flips its Progress row, and returns evidence or failure facts. Two tasks may run in parallel only when their `Files` touch disjoint file/symbol sets and neither task's `Change` consumes what the other produces; tasks sharing a file/symbol or with a dependency run in sequence. The orchestrator merges returned results, reconciles cross-task overlap, and enters Prove once with merged evidence.
 
 ### Single-subagent
 
-When the plan's `Execution mode` is `single-subagent`, the main agent only schedules: it dispatches one task's execution spec at a time to one executor subagent, waits for the return, then merges the returned evidence and enters Prove once. The main agent dispatches one task at a time — only that task's execution spec, not the whole plan. The subagent must reread current named anchors and at most one already-listed neighbor for drift, but never broadly rediscover or redesign; it edits, verifies, appends evidence, and returns the task results and evidence or `BUILD_BLOCKED` facts. The next task continues the same subagent conversation through `send_message`. On DeepSeek Harness (DSH), subagent turns are time-bounded, so one task per round is the norm; a timeout or truncated return retries that one task once with a narrower instruction. Nothing runs in parallel; prefer this mode for small to medium plans or plans whose tasks are strongly dependent, and keep `fan-out` for large parallel plans.
+When the plan's `Execution mode` is `single-subagent`, the main agent only schedules: it dispatches one task's six fields at a time to one executor subagent, waits for the return, then merges the returned evidence and enters Prove once. The subagent reads its anchors, edits, verifies, flips its Progress row, and returns the task result and evidence or `BUILD_BLOCKED` facts. The next task continues the same subagent conversation through `send_message`. On DeepSeek Harness (DSH), subagent turns are time-bounded, so one task per round is the norm; a timeout or truncated return retries that one task once with a narrower instruction. Nothing runs in parallel; prefer this mode for small to medium plans or plans whose tasks are strongly dependent, and keep `fan-out` for large parallel plans.

package/assets/skills/devflow-prove/SKILL.md

@@ -92,6 +92,8 @@ Coverage: <what was verified>
 Not covered: <none or explicit gap>
 ```
 
+On `PASS` with a plan file, write back before reporting: header `Status: done` plus `Landed: <date> · <evidence>`; every `## Progress` row must already be `done` with evidence. `PASS` also requires the `docs/requirements.md` row to be terminal — write `landed` with the evidence, or return the missing-row facts to Core. On `FAIL` or `BLOCKED`, leave `Status` unchanged and report facts to Core.
+
 ## Code Review Report
 
 For code changes, after running the Code Quality Review (General Engineering Review + Language-Specific Checklist), generate this report before claiming PASS or FAIL. Review the actual diff before relying on test results. A Blocker or unresolved Warning returns `FAIL` facts to Core; Recommendations remain visible but do not independently prevent PASS.
@@ -99,8 +101,8 @@ For code changes, after running the Code Quality Review (General Engineering Rev
 ```text
 Code Review Report:
 - Diff reviewed: [actual changed files/ranges].
-- Plan boundary: [approved File Structure row(s) and verdict].
-- Prewalk evidence: [Execution Trace, Handoff Facts, remaining-work completion evidence].
+- Plan boundary: [approved task `Files` rows and verdict; legacy plans may cite `File Structure` rows].
+- Progress evidence: [Progress rows with their Status and recorded command/result; legacy plans may cite Prewalk evidence].
 - Comparable code: [nearest inspected file/symbol and observed convention].
 - Blockers: [count].
   1. [Blocker] [file:line] — [changed-code evidence and concrete risk] → [smallest correction].

package/assets/skills/devflow-prove/references/flow-self-test.md

@@ -383,7 +383,7 @@ Expected behavior:
 - Cut compares nearest order-history patterns and records convention, responsibility, performance, and readability checks.
 - It must not require a Service split, interface, cache, or fixed function length without current evidence.
 - Build makes business intent, key rules, failure paths, and side effects locally understandable, then records a Readability Check.
-- Prove reviews the actual diff against File Structure, Prewalk evidence, project-convention alignment, local understandability, responsibility boundaries, and any cache benefit/invalidation/consistency claim.
+- Prove reviews the actual diff against the plan task boundary, Progress evidence, project-convention alignment, local understandability, responsibility boundaries, and any cache benefit/invalidation/consistency claim.
 - A coherent orchestration change passes when its responsibility, side effects, and direct contracts remain evidenced in the diff.
 - A changed responsibility or unrecorded side effect is a Blocker or Warning only when the diff shows concrete risk; a justified local convention deviation remains non-blocking.
 
@@ -413,20 +413,22 @@ Expected behavior:
 - Brainstorm presents A/B/C after the confirmed request. User-selected A starts Spec directly; Core routes only missing-depth, changed-intent, or non-success facts.
 - Spec must compare real no-change/reuse, direct, and relevant existing-pattern options; it writes the design contract/saved spec, waits for user approval, then an approved A Spec directly enters Cut.
 - A/B `CUT_PASS` directly enters Plan; only `CUT_REDUCE`, `CUT_REUSE`, `CUT_BLOCKED`, or other non-success facts return to Core.
-- A Code change Plan Pack requires a concrete `File Structure` row per target and task-level `Prewalk`: actual `Execution Trace`, `Current Handoff Facts`, and bounded `Remaining Structured Worklist`.
-- A delegated Build agent reads the latest trace, then re-reads only the current work item's anchors and directly changed neighbor. It does not restart broad discovery or re-decide responsibility by default.
+- A v2 Plan Pack carries a slim header, one six-field task per deliverable, a mandatory `Cut` line with a non-empty `Rejected`, and a `## Progress` table.
+- Build may read the current task's anchors and one directly changed neighbor to choose the smallest implementation, flips the task's Progress row, and records the command and result as evidence.
+- Prove writes `Status: done` and `Landed:` on `PASS`; a `done` Progress row without evidence is not `PASS`.
+- A legacy plan that still carries `File Structure` and `Prewalk` remains valid under the legacy rules.
 - A user-approved Plan Pack receives a lightweight Cut-consistency review; an approved A/B Plan directly enters Build, while scope-drift facts return to Core.
 - Saved plan files default to `docs/plans/YYYY-MM-DD-<short-kebab-name>.md`.
 - Must not save implementation plans under `docs/features/`; that directory is for feature ledgers.
 - Must run `node scripts/devflow-plan.js <plan-file>` when the plan is saved to a file. If not found at `scripts/devflow-plan.js` (project-level), try `~/.codex/scripts/devflow-plan.js` or `~/.claude/scripts/devflow-plan.js` (user-level). Do NOT look under `skills/scripts/`.
-- Must fail or revise a plan missing a responsibility map, actual trace evidence, current handoff facts, bounded work items, or concrete verification. The checker does not approve an architecture pattern.
+- Must fail or revise a v2 plan missing `Rejected`, a six-field task, a Progress row matching the task count, evidence on a `done` row, or a runnable `Verify`. The checker does not approve an architecture pattern.
 
 Pass check:
 
 ```text
-CUT_PASS: allowed scope / reuse conclusion / exclusions / verification constraints
+CUT_PASS: 做 / 不做 / 复用 / 验证 plus Rejected
 Command: node scripts/devflow-plan.js docs/plans/YYYY-MM-DD-<short-kebab-name>.md
-Result: DevFlow plan pack report; File Structure: ok; trace and remaining worklist: ok; Judgment: PASS
+Result: DevFlow plan pack report; Format: v2; Cut Rejected: ok; Progress rows match tasks; Judgment: PASS
 Next: lightweight Cut-consistency review -> confirmed Plan and scope-drift facts -> devflow-core
 Judgment: PASS / FAIL / BLOCKED
 ```
@@ -442,8 +444,8 @@ The approved export plan is implemented. Verify it and mark it ready.
 Expected behavior:
 
 - Route: Prove.
-- Prove reads the actual diff before interpreting test output, and compares it with the approved `File Structure`, current `Execution Trace`, `Current Handoff Facts`, remaining-work completion evidence, and nearest comparable code.
-- The Code Review Report names the reviewed diff, plan boundary, Prewalk evidence, comparable code, Blockers, Warnings, Recommendations, and boundary verdict.
+- Prove reads the actual diff before interpreting test output, and compares it with the approved task boundary, Progress evidence, and nearest comparable code.
+- The Code Review Report names the reviewed diff, plan boundary, Progress evidence, comparable code, Blockers, Warnings, Recommendations, and boundary verdict.
 - An unresolved evidence-backed Blocker or Warning returns `FAIL` facts to Core; Recommendations alone do not prevent PASS.
 - A function size, class name, dependency count, cache preference, or fixed architecture shape without changed-code evidence and concrete risk is not a blocking finding.
 
@@ -451,8 +453,8 @@ Pass check:
 
 ```text
 Diff reviewed: actual changed files/ranges
-Plan boundary: File Structure row(s) and verdict
-Prewalk evidence: Trace / Handoff Facts / completion evidence
+Plan boundary: approved task Files rows and verdict
+Progress evidence: row Status plus recorded command/result
 Blockers: 0
 Warnings: 0
 Recommendations: 0 or documented
@@ -686,7 +688,7 @@ Judgment: FAIL
 Input:
 
 ```text
-A Build subagent receives an approved Plan whose latest Prewalk trace records `OrderHistoryQuery`, its API handler, and current authorization behavior. The first remaining work item anchors the query and handler. A minimal anchor reread discovers a new authorization policy that changes denial behavior and the requested rule's placement.
+A Build subagent receives an approved legacy Plan whose latest Prewalk trace records `OrderHistoryQuery`, its API handler, and current authorization behavior. The first remaining work item anchors the query and handler. A minimal anchor reread discovers a new authorization policy that changes denial behavior and the requested rule's placement.
 ```
 
 Expected behavior:

package/assets/skills/devflow-spec/SKILL.md

@@ -52,6 +52,7 @@ Do not force a spec for Design-lite work where a short design contract and quick
    - Design: the comparison names the real alternatives and the selected approach has an explicit trade-off.
 6. Run `node scripts/devflow-spec.js <spec-file>` when the script exists. If not found at `scripts/devflow-spec.js` (project-level), try `~/.codex/scripts/devflow-spec.js` or `~/.claude/scripts/devflow-spec.js` (user-level). Do NOT look under `skills/scripts/`. See `core-methods.md` Script Path Resolution.
 7. **STOP — Wait for user approval of the design contract and spec.** On DSH, request approval with the structured `ask_user_question` tool (single-select: approve / request changes). Tell the user the spec path and review result. If they request changes, revise the comparison/design contract and re-run self-review. An approved A-branch Spec directly enters `devflow-cut`; any non-success state returns facts to `devflow-core`.
+8. On approval, advance the requirement row in `docs/requirements.md` to `designed` and fill the spec path in its artifact column.
 
 ## Output
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devflow-core/dsh-devflow",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "DevFlow for DeepSeek Harness: devflow-2 agent preset + skills + commands + verification scripts, synced into ~/.dsh on host startup.",
   "type": "module",
   "engines": {