@fitlab-ai/agent-infra 0.6.5 → 0.7.0

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 元数据（按需）
 

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

package/templates/.agents/skills/complete-task/SKILL.en.md

@@ -40,9 +40,11 @@ If not found in `active/`, check `blocked/` and `completed/`:
 
 ### 2. Verify Completion Prerequisites (Failure Must Stop)
 
+**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". The completion check below is pruned accordingly.
+
 Before marking complete, verify ALL of these:
-- [ ] All workflow steps are complete (check workflow progress in task.md)
-- [ ] Code has been reviewed (`review.md` or `review-r{N}.md` exists, and the latest review verdict is Approved; or review was done externally)
+- [ ] All workflow steps are complete (check workflow progress in task.md; **for the `pr_tasks` list under each yaml `commit` step, count those items toward the missing-work decision only when `.agents/.airc.json:requiresPullRequest !== false`**)
+- [ ] Code has been reviewed (`review-code.md` or `review-code-r{N}.md` exists, and the latest review verdict is Approved; or review was done externally)
 - [ ] Code has been committed (no uncommitted changes related to this task)
 - [ ] Tests are passing
 
@@ -109,7 +111,7 @@ Check whether `task.md` includes a valid `issue_number`. If not, skip this step
 > Issue sync rules live in `.agents/rules/issue-sync.md`. Read that file before syncing, and complete upstream repository detection plus permission detection.
 
 If a valid `issue_number` exists:
-- First scan and backfill unpublished `task.md`, `analysis*.md`, `plan*.md`, `implementation*.md`, `review*.md`, and `refinement*.md` comments using the backfill rules in `.agents/rules/issue-sync.md` (`task.md` uses the idempotent update path)
+- First scan and backfill unpublished `task.md`, `analysis*.md`, `review-analysis*.md`, `plan*.md`, `review-plan*.md`, `code*.md`, and `review-code*.md` comments using the backfill rules in `.agents/rules/issue-sync.md` (`task.md` uses the idempotent update path)
 - Backfill checked `## Requirements` items to the Issue body by following the requirements-checkbox sync steps in issue-sync.md
 - Do not set any `status:` label — status labels are automatically cleared when the Issue is closed
 - Finally create or update the summary comment marked with the summary marker defined in `.agents/rules/issue-sync.md`

package/templates/.agents/skills/complete-task/SKILL.zh-CN.md

@@ -40,9 +40,11 @@ tail .agents/workspace/active/{task-id}/task.md
 
 ### 2. 验证完成前置条件（未满足则必须停止）
 
+**门控读取（项目级 PR 流程策略）**：在执行本步骤前，读取 `.agents/.airc.json` 的 `requiresPullRequest` 字段；当字段缺失或为 `true` 时视为「启用 PR 流程」（默认），仅当显式为 `false` 时视为「关闭 PR 流程」。下面的工作流步骤完成判定按此规则裁剪。
+
 标记完成之前，验证以下所有条件：
-- [ ] 所有工作流步骤已完成（检查 task.md 中的工作流进度）
-- [ ] 代码已审查（`review.md` 或 `review-r{N}.md` 存在，且最新审查结论为 Approved；或已在外部完成审查）
+- [ ] 所有工作流步骤已完成（检查 task.md 中的工作流进度；**对 yaml 中 commit 步骤的 `pr_tasks` 列表，仅在 `.agents/.airc.json:requiresPullRequest !== false` 时计入未完成判定**）
+- [ ] 代码已审查（`review-code.md` 或 `review-code-r{N}.md` 存在，且最新审查结论为 Approved；或已在外部完成审查）
 - [ ] 代码已提交（没有与此任务相关的未提交变更）
 - [ ] 测试通过
 
@@ -109,7 +111,7 @@ ls .agents/workspace/completed/{task-id}/task.md
 > Issue 同步规则见 `.agents/rules/issue-sync.md`。执行同步前先读取该文件，完成 upstream 仓库检测和权限检测。
 
 如果存在有效的 `issue_number`：
-- 先按 `.agents/rules/issue-sync.md` 的补发规则扫描并补发未发布的 `task.md`、`analysis*.md`、`plan*.md`、`implementation*.md`、`review*.md`、`refinement*.md` 评论（`task.md` 走幂等更新路径）
+- 先按 `.agents/rules/issue-sync.md` 的补发规则扫描并补发未发布的 `task.md`、`analysis*.md`、`review-analysis*.md`、`plan*.md`、`review-plan*.md`、`code*.md`、`review-code*.md` 评论（`task.md` 走幂等更新路径）
 - 按 issue-sync.md 的需求复选框同步步骤，兜底同步 `## 需求` 中已勾选的条目到 Issue body
 - 不要设置 `status:` label — Issue 关闭后 status label 会被自动清除
 - 最后创建或更新 `.agents/rules/issue-sync.md` 中定义的 summary 评论标记对应的 summary 评论

package/templates/.agents/skills/create-pr/SKILL.en.md

@@ -13,6 +13,22 @@ Version stamp rule: when creating or updating `task.md` frontmatter, read `.agen
 
 ## Execution Flow
 
+### Pre-gate: Project-level PR Flow Check
+
+**Gate read (project-level PR flow policy)**: Before running any numbered step, read `.agents/.airc.json`'s `requiresPullRequest` field. Treat missing or `true` as "PR flow enabled" (default); treat explicit `false` as "PR flow disabled".
+
+Branch on the result:
+- missing / `true` -> continue to Step 1 below
+- explicit `false` -> output the message below and **stop immediately**. Do not run any subsequent numbered step, do not trigger any PR-creation command, do not modify `pr_number` in `task.md`, and do not publish a PR summary comment:
+
+```
+This project does not enable the PR flow (`.agents/.airc.json` sets `requiresPullRequest: false`).
+No Pull Request is required; run instead:
+  - Claude Code / OpenCode: /complete-task {task-id}
+  - Gemini CLI: /agent-infra:complete-task {task-id}
+  - Codex CLI: $complete-task {task-id}
+```
+
 ### 1. Parse Command Arguments
 
 Identify arguments from the command input:
@@ -57,7 +73,7 @@ For PRs where `{task-id}` is available, sync the core metadata immediately:
 
 ### 7. Publish the Review Summary
 
-Read the latest context artifacts when they exist: `plan.md` / `plan-r{N}.md`, `implementation.md` / `implementation-r{N}.md`, `review.md` / `review-r{N}.md`, and `refinement.md` / `refinement-r{N}.md`.
+Read the latest context artifacts when they exist: `plan.md` / `plan-r{N}.md`, `review-plan.md` / `review-plan-r{N}.md`, `code.md` / `code-r{N}.md`, and `review-code.md` / `review-code-r{N}.md`.
 
 Aggregate a reviewer-facing summary from those artifacts and maintain a single idempotent summary comment via the hidden marker.
 

package/templates/.agents/skills/create-pr/SKILL.zh-CN.md

@@ -13,6 +13,22 @@ description: "创建 Pull Request 到目标分支"
 
 ## 执行流程
 
+### 前置门控：项目级 PR 流程检查
+
+**门控读取（项目级 PR 流程策略）**：在执行编号步骤前，读取 `.agents/.airc.json` 的 `requiresPullRequest` 字段；当字段缺失或为 `true` 时视为「启用 PR 流程」（默认），仅当显式为 `false` 时视为「关闭 PR 流程」。
+
+按读取结果分支：
+- 缺失 / `true` → 继续到下方第 1 步
+- 显式 `false` → 输出以下消息后**立即停止**，不要执行任何后续编号步骤、不要触发任何 PR 创建命令、不要修改 `task.md` 的 `pr_number`、不要发布 PR 摘要评论：
+
+```
+当前项目未启用 PR 流程（`.agents/.airc.json` 中 `requiresPullRequest: false`）。
+无需创建 Pull Request，请直接运行：
+  - Claude Code / OpenCode：/complete-task {task-id}
+  - Gemini CLI：/agent-infra:complete-task {task-id}
+  - Codex CLI：$complete-task {task-id}
+```
+
 ### 1. 解析命令参数
 
 从命令参数中识别：
@@ -57,7 +73,7 @@ description: "创建 Pull Request 到目标分支"
 
 ### 7. 发布审查摘要
 
-读取最新的上下文产物：`plan.md` / `plan-r{N}.md`、`implementation.md` / `implementation-r{N}.md`、`review.md` / `review-r{N}.md`、`refinement.md` / `refinement-r{N}.md`（存在时）。
+读取最新的上下文产物：`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`（存在时）。
 
 基于这些产物聚合 reviewer 摘要，并使用隐藏标记维护唯一且幂等的摘要评论。
 

package/templates/.agents/skills/import-codescan/SKILL.en.md

@@ -106,5 +106,5 @@ Next step:
 ## Error Handling
 
 - Alert not found: output "Code Scanning alert #{number} not found"
-- Alert already closed: ask the user whether to continue with analysis
+- Alert already closed: **proceed with task creation/reuse by default** and surface the alert's current state (dismissed/fixed) in the final notice; the user may archive the task manually if desired
 - Network/permission error: output the corresponding error information

package/templates/.agents/skills/import-codescan/SKILL.zh-CN.md

@@ -106,5 +106,5 @@ Code Scanning 告警 #{alert-number} 已导入。
 ## 错误处理
 
 - 告警未找到：提示 "Code Scanning alert #{number} not found"
-- 告警已关闭：询问用户是否继续分析
+- 告警已关闭：**默认仍继续创建/复用任务**，并在告知用户中明确该告警当前状态（dismissed/fixed）；用户可视情况手动归档任务
 - 网络/权限错误：提示相应信息

package/templates/.agents/skills/import-dependabot/SKILL.en.md

@@ -29,7 +29,7 @@ Extract key information:
 ### 2. Create the Task Directory and File
 
 Check whether `.agents/workspace/active/` already has a task for this alert.
-- If found, ask the user whether to re-import
+- If found, **reuse the existing task by default**; do not ask the user. State clearly in the final notice: "Reused existing task `{task-id}`; not re-imported." If the user wants to re-import, they must first archive or delete the existing task
 - If not found, create a new task
 
 Create directory: `.agents/workspace/active/TASK-{yyyyMMdd-HHmmss}/`
@@ -110,5 +110,5 @@ Next step:
 ## Error Handling
 
 - Alert not found: output "Security alert #{number} not found"
-- Alert already closed: ask the user whether to continue with analysis
+- Alert already closed: **proceed with task creation/reuse by default** and surface the alert's current state (dismissed/fixed) in the final notice; the user may archive the task manually if desired
 - Network/permission error: output the corresponding error information

package/templates/.agents/skills/import-dependabot/SKILL.zh-CN.md

@@ -29,7 +29,7 @@ description: "导入 Dependabot 安全告警并创建修复任务"
 ### 2. 创建任务目录和文件
 
 检查 `.agents/workspace/active/` 中是否已存在该告警的任务。
-- 如果找到，询问用户是否重新导入
+- 如果找到，**默认复用现有任务**，不询问用户；在最终告知中明确「已复用现有任务 `{task-id}`，未重新导入」。如需重新导入，需先归档/删除已有任务
 - 如果未找到，创建新任务
 
 创建目录：`.agents/workspace/active/TASK-{yyyyMMdd-HHmmss}/`
@@ -110,5 +110,5 @@ node .agents/scripts/validate-artifact.js gate import-dependabot .agents/workspa
 ## 错误处理
 
 - 告警未找到：提示 "Security alert #{number} not found"
-- 告警已关闭：询问用户是否继续分析
+- 告警已关闭：**默认仍继续创建/复用任务**，并在告知用户中明确该告警当前状态（dismissed/fixed）；用户可视情况手动归档任务
 - 网络/权限错误：提示相应信息