@fitlab-ai/agent-infra 0.6.4 → 0.7.0

package/templates/.agents/skills/code-task/reference/dual-mode.zh-CN.md

@@ -0,0 +1,69 @@
+# code-task 双模式判定
+
+本文件说明 `scripts/detect-mode.js` 的行为。脚本是单点真相；修改脚本时必须同步更新本文档。
+
+## 输入
+
+```bash
+node .agents/skills/code-task/scripts/detect-mode.js .agents/workspace/active/{task-id}
+```
+
+脚本扫描任务目录中的 `plan.md` / `plan-r{N}.md`、`review-plan.md` / `review-plan-r{N}.md`、`code.md` / `code-r{N}.md` 和 `review-code.md` / `review-code-r{N}.md`。
+
+## 8 个分支
+
+> 分支按表中自上而下的顺序评估，命中即返回；后续分支不再判定。
+
+| 条件 | mode | exit | 行为 |
+|---|---|---:|---|
+| 无 code 产物 | `init` | 0 | 初次实现，产物为 `code.md` |
+| 最新 review-plan 已批准（`通过` 或 `通过 + major/minor 建议`，即 `Approved` 或 `Approved-with-issues`），且其「审查输入」/「Review Input」字段引用的 plan 文件 == 任务目录中最新的 `plan(-r{N})?.md`，且最新 review-plan 的 mtime > 最新 code 的 mtime | `init` | 0 | plan 已在 code 之后被批准；进入新一轮实现，`next_round = code_max + 1`、`next_artifact = code-r{next_round}.md`。**不论 review-code 是否已审**，本分支均先命中。plan 与 review-plan 的轮次独立递增（如 `plan-r5` 可被 `review-plan-r4` 批准），通过 review-plan 的「审查输入」字段建立批准关系，不要求同号 |
+| `rev_max < code_max` | `error` | 2 | 最新代码未审查，先运行 `review-code` |
+| `rev_max > code_max` | `error` | 2 | 数据状态异常，需要人工检查 |
+| 最新 review-code 为 Approved 且 0/0/0 | `refused` | 1 | 已通过，无需再次运行 `code-task` |
+| 最新 review-code 为 Approved 但有 major/minor | `fix` | 0 | 可选修复模式 |
+| 最新 review-code 为 Changes Requested | `fix` | 0 | 必需修复模式 |
+| 最新 review-code 为 Rejected | `refused` | 1 | 需要重新设计，不进入局部修复 |
+
+## verdict 解析
+
+脚本支持中文和英文 review-code 报告：
+
+| 语义 | 中文 | 英文 |
+|---|---|---|
+| 摘要段落 | `## 审查摘要` | `## Review Summary` |
+| 总体结论字段 | `**总体结论**：` | `**Overall Verdict**:` |
+| 发现统计字段 | `**发现（AI 可处理）**：` | `**Findings (AI-actionable)**:` |
+
+结论映射：
+
+- `通过` / `Approved` -> `Approved`，再按 blocker/major/minor 计数拆成 `Approved` 或 `Approved-with-issues`
+- `需要修改` / `Changes Requested` -> `Changes Requested`
+- `拒绝` / `Rejected` -> `Rejected`
+
+env-blocked 计数不参与 mode 判定。
+
+## 输出契约
+
+脚本输出 JSON：
+
+```json
+{
+  "mode": "init",
+  "code_max": 0,
+  "rev_max": 0,
+  "verdict": null,
+  "next_round": 1,
+  "next_artifact": "code.md",
+  "review_artifact": null,
+  "message": "..."
+}
+```
+
+`review_artifact` 字段在第 2 分支（replan-driven init）下指向触发的 `review-plan-r{N}.md` 而非 review-code 产物，用于追溯触发原因。
+
+exit code：
+
+- `0`：可继续，`mode` 为 `init` 或 `fix`
+- `1`：拒绝继续，`mode` 为 `refused`
+- `2`：状态异常，`mode` 为 `error`

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

@@ -1,6 +1,6 @@
 # Fix Workflow
 
-Read this file before changing code during refinement.
+Read this file before changing code during fix mode.
 
 ## Plan the Fixes
 
@@ -24,7 +24,7 @@ Detailed priority rules:
 
 env-blocked findings are outside the repair scope. Handling rules:
 - do not write code changes for these findings
-- list them unchanged in the refinement report's "Environment-Blocked Handling" section and mark them "outside AI repair scope"
+- list them unchanged in the code report's "Environment-Blocked Handling" section and mark them "outside AI repair scope"
 - do not repeat them under unresolved issues, to avoid visually double-counting them
 - their destination is the PR description, where maintainers carry them as a "manual verification required" checklist
 
@@ -38,7 +38,7 @@ For each fix:
 
 ## Run Test Verification
 
-Before writing the refinement report, run the project's **core subset** as final verification and confirm that all required tests still pass. If the project does not have layered scripts, fall back to the full project test command.
+Before writing the code report, run the project's **core subset** as final verification and confirm that all required tests still pass. If the project does not have layered scripts, fall back to the full project test command.
 
 ## Choose the Next-Step Branch
 
@@ -53,22 +53,22 @@ Prohibition:
 Required output template:
 
 ```text
-Task {task-id} refinement completed.
+Task {task-id} fix completed.
 
-Refinement status:
+Fix status:
 - Blockers fixed: {fixed-blockers}/{total-blockers}
 - Major issues fixed: {fixed-majors}/{total-majors}
 - Minor issues fixed: {fixed-minors}/{total-minors}
 - [If env-blocked > 0] env-blocked skipped: {count}
 - All tests passing: {yes/no}
 - Review input: {review-artifact}
-- Refinement artifact: {refinement-artifact}
+- Code artifact: {code-artifact}
 
 Next step - re-review or commit:
 - Re-review (always recommended):
-  - 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}
 - Commit directly (optional; only when all issues are resolved and changes are low risk):
   - Claude Code / OpenCode: /commit
   - Gemini CLI: /agent-infra:commit
@@ -77,9 +77,9 @@ Next step - re-review or commit:
 
 ## Notes
 
-1. **Prerequisite**: a review artifact must exist (`review.md` or `review-r{N}.md`)
+1. **Prerequisite**: a code review artifact must exist (`review-code.md` or `review-code-r{N}.md`)
 2. **No auto-commit**: do not run `git commit`
 3. **Scope discipline**: only fix reviewed issues
 4. **Disagreement handling**: record any disagreement in the report
-5. **Re-review**: always recommend `review-task` as the default next step after refinement
-6. **Consistency**: the latest review artifact, Activity Log entry, and refinement report must reference the same round
+5. **Re-review**: always recommend `review-code` as the default next step after fix mode
+6. **Consistency**: the latest review artifact, Activity Log entry, and code report must reference the same round

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

@@ -59,8 +59,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

@@ -59,8 +59,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 元数据（按需）