@fitlab-ai/agent-infra 0.6.5 → 0.7.1

package/templates/.agents/skills/{refine-task/reference/fix-workflow.zh-CN.md → code-task/reference/fix-mode.zh-CN.md}

@@ -24,7 +24,7 @@
 
 env-blocked 项不在修复范围。处理规则：
 - 不要为这些项编写代码改动
-- 在 refinement 报告的「环境性遗留处理」段落原样列出，标注「不在 AI 修复范围」
+- 在 code 报告的「环境性遗留处理」段落原样列出，标注「不在 AI 修复范围」
 - 不要在 unresolved 段落里重复列出（避免视觉计数翻倍）
 - 这些项的去向：维护者在 PR description 中以「待人工验证」清单承接
 
@@ -38,7 +38,7 @@ env-blocked 项不在修复范围。处理规则：
 
 ## 运行测试验证
 
-写 refinement 报告前，运行项目测试的 **core 子集**做最终验证，确保所有必需测试仍然通过。如果项目没有分层 script，回退到完整项目测试命令。
+写 code 报告前，运行项目测试的 **core 子集**做最终验证，确保所有必需测试仍然通过。如果项目没有分层 script，回退到完整项目测试命令。
 
 ## 选择下一步分支
 
@@ -62,13 +62,13 @@ env-blocked 项不在修复范围。处理规则：
 - [如 env-blocked > 0] 环境性遗留跳过：{数量}
 - 所有测试通过：{是/否}
 - 审查输入：{review-artifact}
-- 修复产物：{refinement-artifact}
+- 修复产物：{code-artifact}
 
 下一步 - 重新审查或提交：
 - 重新审查（始终推荐）：
-  - Claude Code / OpenCode：/review-task {task-id}
-  - Gemini CLI：/agent-infra:review-task {task-id}
-  - Codex CLI：$review-task {task-id}
+  - Claude Code / OpenCode：/review-code {task-id}
+  - Gemini CLI：/agent-infra:review-code {task-id}
+  - Codex CLI：$review-code {task-id}
 - 直接提交（可选；仅在所有问题已解决且风险可控时）：
   - Claude Code / OpenCode：/commit
   - Gemini CLI：/agent-infra:commit
@@ -77,9 +77,9 @@ env-blocked 项不在修复范围。处理规则：
 
 ## 注意事项
 
-1. **前置条件**：必须存在审查产物（`review.md` 或 `review-r{N}.md`）
+1. **前置条件**：必须存在代码审查产物（`review-code.md` 或 `review-code-r{N}.md`）
 2. **禁止自动提交**：不要执行 `git commit`
 3. **范围约束**：只修复审查中列出的问题
 4. **分歧处理**：如果不同意审查意见，要在报告里明确记录
-5. **重新审查**：修复后始终推荐执行 `review-task`
+5. **重新审查**：修复后始终推荐执行 `review-code`
 6. **一致性**：最新审查产物、Activity Log 记录和修复报告必须引用同一轮次

package/templates/.agents/skills/code-task/reference/output-template.en.md

@@ -0,0 +1,20 @@
+# Output Template
+
+When reporting that implementation is complete, use the following standard format:
+
+```text
+Task {task-id} code implementation complete.
+
+Summary:
+- Implementation round: Round {code-round}
+- Files modified: {count}
+- All tests passed: {yes/no}
+
+Output files:
+- Code report: .agents/workspace/active/{task-id}/{code-artifact}
+
+Next step - code review:
+  - Claude Code / OpenCode: /review-code {task-id}
+  - Gemini CLI: /{{project}}:review-code {task-id}
+  - Codex CLI: $review-code {task-id}
+```

package/templates/.agents/skills/code-task/reference/output-template.zh-CN.md

@@ -0,0 +1,20 @@
+# 输出模板
+
+向用户汇报实现完成时，使用以下标准格式：
+
+```text
+任务 {task-id} 实现完成。
+
+摘要：
+- 实现轮次：Round {code-round}
+- 修改文件：{数量}
+- 所有测试通过：{是/否}
+
+产出文件：
+- 实现报告：.agents/workspace/active/{task-id}/{code-artifact}
+
+下一步 - 代码审查：
+  - Claude Code / OpenCode：/review-code {task-id}
+  - Gemini CLI：/agent-infra:review-code {task-id}
+  - Codex CLI：$review-code {task-id}
+```

package/templates/.agents/skills/{implement-task → code-task}/reference/report-template.en.md

@@ -1,14 +1,14 @@
-# Implementation Report Template
+# Code Report Template
 
-Use this structure when creating `implementation.md` or `implementation-r{N}.md`.
+Use this structure when creating `code.md` or `code-r{N}.md`.
 
 ## Output Template
 
 ```markdown
 # Implementation Report
 
-- **Implementation Round**: Round {implementation-round}
-- **Artifact File**: `{implementation-artifact}`
+- **Implementation Round**: Round {code-round}
+- **Artifact File**: `{code-artifact}`
 
 ## State Check
 

package/templates/.agents/skills/{implement-task → code-task}/reference/report-template.zh-CN.md

@@ -1,14 +1,14 @@
 # 实现报告模板
 
-创建 `implementation.md` 或 `implementation-r{N}.md` 时，使用以下结构。
+创建 `code.md` 或 `code-r{N}.md` 时，使用以下结构。
 
 ## 输出模板
 
 ```markdown
 # 实现报告
 
-- **实现轮次**: Round {implementation-round}
-- **产物文件**: `{implementation-artifact}`
+- **实现轮次**: Round {code-round}
+- **产物文件**: `{code-artifact}`
 
 ## 状态核对
 

package/templates/.agents/skills/code-task/scripts/detect-mode.js

@@ -0,0 +1,370 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+function main() {
+  const taskDir = process.argv[2];
+  if (!taskDir) {
+    writeResult({
+      mode: "error",
+      code_max: 0,
+      rev_max: 0,
+      verdict: null,
+      next_round: null,
+      next_artifact: null,
+      review_artifact: null,
+      message: "Task directory argument is required."
+    }, 2);
+    return;
+  }
+
+  try {
+    const resolvedTaskDir = path.resolve(taskDir);
+    const taskId = path.basename(resolvedTaskDir);
+    const entries = fs.readdirSync(resolvedTaskDir);
+    const codeMax = maxRound(entries, "code");
+    const revMax = maxRound(entries, "review-code");
+
+    if (codeMax === 0) {
+      writeResult({
+        mode: "init",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict: null,
+        next_round: 1,
+        next_artifact: "code.md",
+        review_artifact: null,
+        message: "No prior code artifact. Starting initial implementation (round 1 -> code.md)."
+      }, 0);
+      return;
+    }
+
+    // replan-precedes-unreviewed-code:
+    // 第 8 分支（replan）必须在第 2 分支（revMax < codeMax → error）之前评估。
+    // 依据 task.md 盲区 B 修法 B1：「不论 review-code 状态如何（包括未审）」，
+    // 只要最新 review-plan 已批准且 mtime > code，就进入新一轮实现。
+    const planMax = maxRound(entries, "plan");
+    const reviewPlanMax = maxRound(entries, "review-plan");
+    const replanCheck = checkPlanAheadOfCode({
+      resolvedTaskDir,
+      codeMax,
+      planMax,
+      reviewPlanMax
+    });
+    if (replanCheck.replan) {
+      const nextRound = codeMax + 1;
+      const nextArtifact = artifactName("code", nextRound);
+      writeResult({
+        mode: "init",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict: null,
+        next_round: nextRound,
+        next_artifact: nextArtifact,
+        review_artifact: replanCheck.reviewPlanArtifact,
+        message: `Latest ${replanCheck.reviewPlanArtifact} is approved and its mtime is newer than the latest code artifact. Entering replan-driven init (round ${nextRound} -> ${nextArtifact}).`
+      }, 0);
+      return;
+    }
+
+    if (revMax < codeMax) {
+      const expected = artifactName("review-code", codeMax);
+      writeResult({
+        mode: "error",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict: null,
+        next_round: null,
+        next_artifact: null,
+        review_artifact: expected,
+        message: `Code round ${codeMax} has no matching review-code artifact (${expected} expected). Run /review-code ${taskId} first.`
+      }, 2);
+      return;
+    }
+
+    if (revMax > codeMax) {
+      writeResult({
+        mode: "error",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict: null,
+        next_round: null,
+        next_artifact: null,
+        review_artifact: artifactName("review-code", revMax),
+        message: `Inconsistent state: review-code round ${revMax} > code round ${codeMax}. Manual inspection required.`
+      }, 2);
+      return;
+    }
+
+    const reviewArtifact = artifactName("review-code", revMax);
+    const verdictResult = parseVerdict(path.join(resolvedTaskDir, reviewArtifact));
+    if (!verdictResult.ok) {
+      writeResult({
+        mode: "error",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict: verdictResult.verdict ?? null,
+        next_round: null,
+        next_artifact: null,
+        review_artifact: reviewArtifact,
+        message: verdictResult.message
+      }, 2);
+      return;
+    }
+
+    const verdict = verdictResult.verdict;
+    if (verdict === "Approved") {
+      writeResult({
+        mode: "refused",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict,
+        next_round: null,
+        next_artifact: null,
+        review_artifact: reviewArtifact,
+        message: `Latest ${reviewArtifact} verdict is Approved with no findings. Nothing to fix. Run /commit to proceed.`
+      }, 1);
+      return;
+    }
+
+    if (verdict === "Rejected") {
+      writeResult({
+        mode: "refused",
+        code_max: codeMax,
+        rev_max: revMax,
+        verdict,
+        next_round: null,
+        next_artifact: null,
+        review_artifact: reviewArtifact,
+        message: `Latest ${reviewArtifact} verdict is Rejected. This requires a fresh implementation strategy; re-plan or discuss with maintainers before re-running /code-task ${taskId}.`
+      }, 1);
+      return;
+    }
+
+    const nextRound = codeMax + 1;
+    const nextArtifact = artifactName("code", nextRound);
+    const optional = verdict === "Approved-with-issues";
+    writeResult({
+      mode: "fix",
+      code_max: codeMax,
+      rev_max: revMax,
+      verdict,
+      next_round: nextRound,
+      next_artifact: nextArtifact,
+      review_artifact: reviewArtifact,
+      message: optional
+        ? `Latest ${reviewArtifact} approved with non-blocking findings. Entering optional fix mode (round ${nextRound} -> ${nextArtifact}).`
+        : `Latest ${reviewArtifact} requests changes. Entering required fix mode (round ${nextRound} -> ${nextArtifact}).`
+    }, 0);
+  } catch (error) {
+    writeResult({
+      mode: "error",
+      code_max: 0,
+      rev_max: 0,
+      verdict: null,
+      next_round: null,
+      next_artifact: null,
+      review_artifact: null,
+      message: `Mode detection failed: ${error instanceof Error ? error.message : String(error)}`
+    }, 2);
+  }
+}
+
+function maxRound(entries, stem) {
+  let max = 0;
+  for (const entry of entries) {
+    if (entry === `${stem}.md`) {
+      max = Math.max(max, 1);
+      continue;
+    }
+
+    const match = entry.match(new RegExp(`^${escapeRegExp(stem)}-r(\\d+)\\.md$`));
+    if (match) {
+      max = Math.max(max, Number(match[1]));
+    }
+  }
+  return max;
+}
+
+function artifactName(stem, round) {
+  return round === 1 ? `${stem}.md` : `${stem}-r${round}.md`;
+}
+
+function checkPlanAheadOfCode({ resolvedTaskDir, codeMax, planMax, reviewPlanMax }) {
+  if (planMax === 0 || reviewPlanMax === 0) {
+    return { replan: false };
+  }
+
+  // plan 和 review-plan 轮次独立递增（plan-r5 可被 review-plan-r4 批准），不能假设同号。
+  // 用最新 review-plan 产物的「审查输入」/「Review Input」段落里引用的 plan 文件名
+  // 作为真正被批准的 plan；若该 plan 文件名不等于目录里最新 plan-rN.md，
+  // 说明最新 plan 还未被审查，不触发 replan。
+  const reviewPlanArtifact = artifactName("review-plan", reviewPlanMax);
+  const reviewPlanPath = path.join(resolvedTaskDir, reviewPlanArtifact);
+  if (!fs.existsSync(reviewPlanPath)) {
+    return { replan: false };
+  }
+
+  const reviewedPlan = parseReviewedPlan(reviewPlanPath);
+  if (!reviewedPlan) {
+    return { replan: false };
+  }
+  const latestPlanArtifact = artifactName("plan", planMax);
+  if (reviewedPlan !== latestPlanArtifact) {
+    return { replan: false };
+  }
+
+  // review-plan 的「通过 + 主要/次要建议」（Approved-with-issues）仍是已批准，
+  // 区别于 review-code（Approved-with-issues 触发 optional fix）。replan 检测对
+  // review-plan 放宽到 Approved + Approved-with-issues 二者均放行。
+  const APPROVED_PLAN_VERDICTS = new Set(["Approved", "Approved-with-issues"]);
+  const reviewVerdict = parseVerdict(reviewPlanPath);
+  if (!reviewVerdict.ok || !APPROVED_PLAN_VERDICTS.has(reviewVerdict.verdict)) {
+    return { replan: false };
+  }
+
+  const codeArtifact = artifactName("code", codeMax);
+  const codeStat = safeStat(path.join(resolvedTaskDir, codeArtifact));
+  const reviewPlanStat = safeStat(reviewPlanPath);
+  if (!codeStat || !reviewPlanStat) {
+    return { replan: false };
+  }
+
+  // 严格 `>`：同秒回退到既有 7 分支逻辑（保守，参见 plan-r5.md Q2 决议）
+  if (reviewPlanStat.mtimeMs > codeStat.mtimeMs) {
+    return { replan: true, reviewPlanArtifact };
+  }
+  return { replan: false };
+}
+
+function parseReviewedPlan(reviewPlanPath) {
+  let content;
+  try {
+    content = fs.readFileSync(reviewPlanPath, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = content.split(/\r?\n/);
+  const headerPattern = /^[-*]\s*\*\*(?:审查输入|Review Input)\*\*[:：]/;
+  const planFilePattern = /`(plan(?:-r\d+)?\.md)`/;
+  let inHeader = false;
+  for (const line of lines) {
+    if (headerPattern.test(line)) {
+      inHeader = true;
+      const inline = line.match(planFilePattern);
+      if (inline) return inline[1];
+      continue;
+    }
+    if (!inHeader) continue;
+    if (/^\s*[-*]\s/.test(line)) {
+      const match = line.match(planFilePattern);
+      if (match) return match[1];
+      continue;
+    }
+    if (line.trim() === "") continue;
+    break;
+  }
+  return null;
+}
+
+function safeStat(filePath) {
+  try {
+    return fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function parseVerdict(reviewPath) {
+  if (!fs.existsSync(reviewPath)) {
+    return { ok: false, verdict: null, message: `Review artifact not found: ${path.basename(reviewPath)}` };
+  }
+
+  const content = fs.readFileSync(reviewPath, "utf8");
+  const summary = extractSection(content, ["审查摘要", "Review Summary"]);
+  const fileName = path.basename(reviewPath);
+  if (!summary) {
+    return { ok: false, verdict: null, message: `cannot locate review summary section in ${fileName}` };
+  }
+
+  const verdictMatch = summary.match(/^[-*]?\s*\*\*(?:总体结论|Overall Verdict)\*\*[:：]\s*(.+?)\s*$/im);
+  if (!verdictMatch) {
+    return { ok: false, verdict: null, message: `cannot parse verdict in ${fileName}` };
+  }
+
+  const verdict = normalizeVerdict(verdictMatch[1]);
+  if (!verdict) {
+    return {
+      ok: false,
+      verdict: null,
+      message: `unrecognized verdict '${verdictMatch[1].trim()}' in ${fileName}`
+    };
+  }
+
+  if (verdict !== "Approved") {
+    return { ok: true, verdict };
+  }
+
+  const findingsMatch = summary.match(/^[-*]?\s*\*\*(?:发现（AI 可处理）|Findings \(AI-actionable\))\*\*[:：]\s*(.+?)\s*$/im);
+  if (!findingsMatch) {
+    return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+  }
+
+  const counts = findingsMatch[1].match(/(\d+)\s*(?:阻塞项|blockers?).*?(\d+)\s*(?:主要|majors?).*?(\d+)\s*(?:次要|minors?)/i);
+  if (!counts) {
+    return { ok: false, verdict, message: `cannot parse findings count in ${fileName}` };
+  }
+
+  const [, blockers, majors, minors] = counts.map(Number);
+  return {
+    ok: true,
+    verdict: blockers === 0 && majors === 0 && minors === 0 ? "Approved" : "Approved-with-issues"
+  };
+}
+
+function normalizeVerdict(raw) {
+  const value = String(raw).trim().toLowerCase();
+  if (value === "通过" || value === "approved") {
+    return "Approved";
+  }
+  if (value === "需要修改" || value === "changes requested") {
+    return "Changes Requested";
+  }
+  if (value === "拒绝" || value === "rejected") {
+    return "Rejected";
+  }
+  return "";
+}
+
+function extractSection(content, names) {
+  const lines = content.split(/\r?\n/);
+  const nameSet = new Set(names);
+  const start = lines.findIndex((line) => {
+    const match = line.trim().match(/^##\s+(.+?)\s*$/);
+    return match ? nameSet.has(match[1]) : false;
+  });
+
+  if (start === -1) {
+    return "";
+  }
+
+  const sectionLines = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index])) {
+      break;
+    }
+    sectionLines.push(lines[index]);
+  }
+  return sectionLines.join("\n");
+}
+
+function writeResult(result, code) {
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  process.exitCode = code;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+main();

package/templates/.agents/skills/commit/SKILL.en.md

@@ -17,6 +17,10 @@ When updating related `task.md` frontmatter, read `.agents/rules/version-stamp.m
 | "`git add -A` is faster." | `git add -A` and `git add .` are forbidden; stage only explicitly listed files to avoid including unrelated changes. |
 | "This file has a copyright header, but the year can wait." | If you changed it, update the copyright year using `date +%Y`; this is a hard pre-commit check. |
 
+## Task id short ref
+
+> If `{task-id}` begins with `#`, follow the "SKILL parameter resolver" section of `.agents/rules/task-short-id.md`; treat `{task-id}` as the resolved full `TASK-YYYYMMDD-HHMMSS` form for every downstream command.
+
 ## 1. Check Local Modifications (CRITICAL)
 
 Before any edit, inspect:
@@ -59,8 +63,8 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 Append the Commit Activity Log entry and choose exactly one next-step case:
 - final commit -> `complete-task {task-id}`
 - more work remains -> update task.md and stop
-- ready for review -> `review-task {task-id}`
-- ready for PR -> `create-pr`
+- ready for review -> `review-code {task-id}`
+- ready for PR (only when the project enables the PR flow, i.e. `requiresPullRequest !== false`) -> `create-pr`
 
 ## 6. Sync Issue Metadata When Applicable
 

package/templates/.agents/skills/commit/SKILL.zh-CN.md

@@ -17,6 +17,10 @@ description: "提交当前变更到 Git"
 | 「`git add -A` 更省事」 | 禁止 `git add -A`/`git add .`；只暂存明确列出的文件，避免带入无关改动。 |
 | 「改了带版权头的文件，年份先不动」 | 改了就更新版权年份（动态取 `date +%Y`），这是提交前的硬性检查。 |
 
+## 任务入参短号别名
+
+> 如果 `{task-id}` 入参以 `#` 开头，先读取 `.agents/rules/task-short-id.md` 的「SKILL 入参解析」段执行解析；后续命令视 `{task-id}` 为解析后的全长 `TASK-YYYYMMDD-HHMMSS` 形式。
+
 ## 1. 检查本地修改（关键）
 
 在任何编辑前先检查：
@@ -59,8 +63,8 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 追加 Commit 的 Activity Log，并且只能选择一个下一步分支：
 - 最终提交 -> `complete-task {task-id}`
 - 还有后续工作 -> 更新 task.md 后停止
-- 准备审查 -> `review-task {task-id}`
-- 准备创建 PR -> `create-pr`
+- 准备审查 -> `review-code {task-id}`
+- 准备创建 PR（仅项目启用 PR 流程，即 `requiresPullRequest !== false`）-> `create-pr`
 
 ## 6. 同步 Issue 元数据（按需）
 

package/templates/.agents/skills/commit/reference/task-status-update.en.md

@@ -20,9 +20,11 @@ For every task-related commit, append this Activity Log entry in `task.md`:
 
 Before selecting the next step, verify:
 - `current_step` and the latest workflow progress in `task.md`
-- whether the latest `review.md` / `review-r{N}.md` passed without findings
+- whether the latest `review-code.md` / `review-code-r{N}.md` passed without findings
 - whether there are still pending fixes, review work, or PR creation steps
 
+**Gate read (project-level PR flow policy)**: Before running this step, read `.agents/.airc.json`'s `requiresPullRequest` field. Treat missing or `true` as "PR flow enabled" (default); treat explicit `false` as "PR flow disabled". All branches that depend on this field follow the same rule.
+
 Choose exactly one case:
 
 | Decision Basis | Required Case |
@@ -30,17 +32,19 @@ Choose exactly one case:
 | all workflow steps completed + latest review approved with no findings + all tests passed | Case 1: final commit |
 | unfinished steps, pending fixes, or waiting on others still exist | Case 2: more work remains |
 | this commit prepares the task for code review | Case 3: ready for review |
-| code is committed, review is done, and the next step is PR creation | Case 4: ready for PR |
+| code is committed, review is done, **and the project enables the PR flow**, with PR creation as the next step | Case 4: ready for PR |
 
 Never apply more than one case. Match the single next-step branch first, then update the task.
 
+**Gate downgrade**: When `requiresPullRequest === false`, Case 4 must never be entered; commits that would otherwise fall into Case 4 collapse into Case 1 (final commit -> `/complete-task`).
+
 ### Case 1: Final Commit
 
 Prerequisites:
 - [ ] all code committed
 - [ ] all tests passed
 - [ ] code review approved
-- [ ] all workflow steps completed
+- [ ] all workflow steps completed (for the `pr_tasks` list under each yaml `commit` step, count those items toward completion only when `requiresPullRequest !== false`)
 
 Required next-step commands:
 
@@ -71,9 +75,9 @@ Required next-step commands:
 
 ```text
 Next step - code review:
-  - Claude Code / OpenCode: /review-task {task-id}
-  - Gemini CLI: /agent-infra:review-task {task-id}
-  - Codex CLI: $review-task {task-id}
+  - Claude Code / OpenCode: /review-code {task-id}
+  - Gemini CLI: /agent-infra:review-code {task-id}
+  - Codex CLI: $review-code {task-id}
 ```
 
 ### Case 4: Ready for PR

package/templates/.agents/skills/commit/reference/task-status-update.zh-CN.md

@@ -20,9 +20,11 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 
 在决定下一步之前，先确认：
 - `task.md` 中的 `current_step` 和最新工作流进度
-- 最新的 `review.md` / `review-r{N}.md` 是否无问题通过
+- 最新的 `review-code.md` / `review-code-r{N}.md` 是否无问题通过
 - 是否仍然存在待修复项、待审查工作或待创建 PR 的步骤
 
+**门控读取（项目级 PR 流程策略）**：在执行本步骤前，读取 `.agents/.airc.json` 的 `requiresPullRequest` 字段；当字段缺失或为 `true` 时视为「启用 PR 流程」（默认），仅当显式为 `false` 时视为「关闭 PR 流程」。所有依赖该字段的分支按此规则判定。
+
 必须且只能选择一个分支：
 
 | 判断依据 | 必选分支 |
@@ -30,17 +32,19 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 | 所有工作流步骤都已完成 + 最新审查无问题通过 + 所有测试通过 | 场景 1：最终提交 |
 | 仍有未完成步骤、待修复项或等待他人的动作 | 场景 2：还有后续工作 |
 | 这次提交是为了把任务交给代码审查 | 场景 3：准备进入审查 |
-| 代码已提交、审查已完成，下一步是创建 PR | 场景 4：准备创建 PR |
+| 代码已提交、审查已完成，且**项目启用 PR 流程**，下一步是创建 PR | 场景 4：准备创建 PR |
 
 绝对不要同时套用多个分支。先匹配唯一的下一步分支，再更新任务。
 
+**门控降级**：当 `requiresPullRequest === false` 时，场景 4 永远不被进入；原本会落入场景 4 的提交统一收敛到场景 1（最终提交 → `/complete-task`）。
+
 ### 场景 1：最终提交
 
 前置条件：
 - [ ] 所有代码都已提交
 - [ ] 所有测试通过
 - [ ] 代码审查已通过
-- [ ] 所有工作流步骤已完成
+- [ ] 所有工作流步骤已完成（对 yaml `commit` 步骤的 `pr_tasks` 列表，仅在 `requiresPullRequest !== false` 时计入）
 
 必带下一步命令：
 
@@ -71,9 +75,9 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 
 ```text
 下一步 - 代码审查：
-  - Claude Code / OpenCode: /review-task {task-id}
-  - Gemini CLI: /agent-infra:review-task {task-id}
-  - Codex CLI: $review-task {task-id}
+  - Claude Code / OpenCode: /review-code {task-id}
+  - Gemini CLI: /agent-infra:review-code {task-id}
+  - Codex CLI: $review-code {task-id}
 ```
 
 ### 场景 4：准备创建 PR