@fitlab-ai/agent-infra 0.5.8 → 0.5.10

package/templates/.agents/scripts/{platform-adapters/find-existing-task.github.js → find-existing-task.js}

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { text } from "node:stream/consumers";
 import { pathToFileURL } from "node:url";
 
 const markerPattern = /^<!-- sync-issue:(TASK-\d{8}-\d{6}):([a-z][a-z0-9-]*) -->$/;
@@ -10,16 +10,6 @@ function parseArgs(argv) {
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (arg === "--issue") {
-      args.issue = argv[index + 1];
-      index += 1;
-      continue;
-    }
-    if (arg === "--repo") {
-      args.repo = argv[index + 1];
-      index += 1;
-      continue;
-    }
     if (arg === "--format") {
       args.format = argv[index + 1];
       index += 1;
@@ -38,53 +28,12 @@ function parseArgs(argv) {
 function usage() {
   return [
     "Usage:",
-    "  node .agents/scripts/platform-adapters/find-existing-task.js --issue <number> [--repo <owner/name>] [--format json]"
+    "  <issue comments JSON via stdin> | node .agents/scripts/find-existing-task.js [--format json]",
+    "",
+    "Reads issue comments JSON (JSON Lines or JSON Array) from stdin and prints {found, task_id, frontmatter?}."
   ].join("\n");
 }
 
-function runGh(args) {
-  const ghBin = process.env.IMPORT_ISSUE_GH_BIN || "gh";
-  const result = spawnSync(ghBin, args, {
-    encoding: "utf8",
-    maxBuffer: 10 * 1024 * 1024
-  });
-
-  if (result.error) {
-    const error = new Error(`gh command failed: ${result.error.message}`);
-    error.stderr = result.error.message;
-    throw error;
-  }
-
-  if (result.status !== 0) {
-    const stderr = result.stderr.trim() || `gh exited with status ${result.status}`;
-    const error = new Error(stderr);
-    error.stderr = stderr;
-    throw error;
-  }
-
-  return result.stdout;
-}
-
-function resolveRepo(explicitRepo) {
-  if (explicitRepo) {
-    return explicitRepo;
-  }
-
-  const currentRepo = runGh(["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]).trim();
-  if (!currentRepo) {
-    throw new Error("Cannot detect current GitHub repository");
-  }
-
-  const upstreamRepo = runGh([
-    "api",
-    `repos/${currentRepo}`,
-    "--jq",
-    "if .fork then .parent.full_name else .full_name end"
-  ]).trim();
-
-  return upstreamRepo || currentRepo;
-}
-
 function parseComments(output) {
   const trimmed = output.trim();
   if (!trimmed) {
@@ -102,18 +51,6 @@ function parseComments(output) {
   }
 }
 
-function fetchComments(repo, issueNumber) {
-  const output = runGh([
-    "api",
-    `repos/${repo}/issues/${issueNumber}/comments`,
-    "--paginate",
-    "--jq",
-    ".[] | @json"
-  ]);
-
-  return parseComments(output);
-}
-
 function firstLine(value) {
   return String(value || "").split(/\r?\n/, 1)[0].trim();
 }
@@ -231,7 +168,7 @@ function buildResult(comments) {
   return result;
 }
 
-function main() {
+async function main() {
   let args;
   try {
     args = parseArgs(process.argv.slice(2));
@@ -246,27 +183,33 @@ function main() {
     return;
   }
 
-  if (!args.issue) {
-    console.error("Missing required argument: --issue");
-    console.error(usage());
+  if (args.format !== "json") {
+    console.error(`Unsupported format: ${args.format}`);
     process.exit(1);
   }
 
-  if (args.format !== "json") {
-    console.error(`Unsupported format: ${args.format}`);
+  let raw;
+  try {
+    raw = await text(process.stdin);
+  } catch (error) {
+    console.error(`Cannot read stdin: ${error.message}`);
     process.exit(1);
   }
 
+  let comments;
   try {
-    const repo = resolveRepo(args.repo);
-    const comments = fetchComments(repo, args.issue);
-    console.log(JSON.stringify(buildResult(comments), null, 2));
+    comments = parseComments(raw);
   } catch (error) {
-    console.error(`Cannot scan issue comments: ${error.stderr || error.message}`);
-    process.exit(2);
+    console.error(`Cannot parse stdin as JSON: ${error.message}`);
+    process.exit(1);
   }
+
+  console.log(JSON.stringify(buildResult(comments), null, 2));
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  main();
+  main().catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
 }

package/templates/.agents/scripts/platform-adapters/platform-sync.github.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
-import { spawnSync } from "node:child_process";
+import spawn from "cross-spawn";
 
 const CHECK_TYPE = "platform-sync";
 const DEFAULT_RETRY_DELAYS_MS = [3000, 10000];
@@ -498,7 +498,7 @@ function checkPrCommentLastCommit(context, remoteData) {
     );
   }
 
-  const headResult = withRetry(() => gitText(["rev-parse", "HEAD"], context.taskDir));
+  const headResult = resolvePrHeadSha(context);
   if (!headResult.ok) {
     return headResult.type === "check_failed"
       ? failResult(CHECK_TYPE, headResult.message, headResult.type)
@@ -1034,7 +1034,7 @@ function resolveUpstreamRepo(taskDir) {
 }
 
 function resolveOwnerRepo(taskDir) {
-  const gitResult = spawnSync("git", ["remote", "get-url", "origin"], {
+  const gitResult = spawn.sync("git", ["remote", "get-url", "origin"], {
     cwd: taskDir,
     encoding: "utf8"
   });
@@ -1097,12 +1097,12 @@ function ghText(args, cwd) {
 }
 
 function ghCommand(args, cwd) {
-  const command = resolveCommand("gh");
-  const result = spawnSync(command, args, commandOptions(command, {
+  const gh = resolveGhCommand();
+  const result = spawn.sync(gh.command, [...gh.preArgs, ...args], {
     cwd,
     encoding: "utf8",
     env: process.env
-  }));
+  });
 
   if (result.status !== 0) {
     const stderr = `${result.stderr || ""}${result.stdout || ""}`.trim();
@@ -1113,17 +1113,35 @@ function ghCommand(args, cwd) {
   return { ok: true, value: result.stdout };
 }
 
+function resolveGhCommand() {
+  const command = process.env.AGENT_INFRA_GH_BIN || "gh";
+  const rawPreArgs = process.env.AGENT_INFRA_GH_ARGS_JSON;
+  if (!rawPreArgs) {
+    return { command, preArgs: [] };
+  }
+
+  try {
+    const preArgs = JSON.parse(rawPreArgs);
+    if (Array.isArray(preArgs) && preArgs.every((arg) => typeof arg === "string")) {
+      return { command, preArgs };
+    }
+  } catch {
+    return { command, preArgs: [] };
+  }
+
+  return { command, preArgs: [] };
+}
+
 function ghPaginatedJson(args, cwd) {
   return ghJson(args, cwd);
 }
 
 function gitText(args, cwd) {
-  const command = resolveCommand("git");
-  const result = spawnSync(command, args, commandOptions(command, {
+  const result = spawn.sync("git", args, {
     cwd,
     encoding: "utf8",
     env: process.env
-  }));
+  });
 
   if (result.status !== 0) {
     const stderr = `${result.stderr || ""}${result.stdout || ""}`.trim();
@@ -1137,6 +1155,51 @@ function gitText(args, cwd) {
   return { ok: true, value: String(result.stdout || "").trim() };
 }
 
+function resolvePrHeadSha(context) {
+  const fallback = () => withRetry(() => gitText(["rev-parse", "HEAD"], context.taskDir));
+  const branch = String(context.task?.metadata?.branch || "").trim();
+  if (!branch) {
+    return fallback();
+  }
+
+  const worktreeList = withRetry(() => gitText(["worktree", "list", "--porcelain"], context.taskDir));
+  if (!worktreeList.ok) {
+    return fallback();
+  }
+
+  const matchedWorktree = findWorktreeForBranch(worktreeList.value, branch);
+  if (!matchedWorktree) {
+    return fallback();
+  }
+
+  const headInWorktree = withRetry(() => gitText(["rev-parse", "HEAD"], matchedWorktree));
+  if (!headInWorktree.ok) {
+    return fallback();
+  }
+
+  return headInWorktree;
+}
+
+function findWorktreeForBranch(porcelainOutput, branch) {
+  let currentWorktree = "";
+  for (const rawLine of String(porcelainOutput || "").split("\n")) {
+    const line = rawLine.trimEnd();
+    if (line.startsWith("worktree ")) {
+      currentWorktree = line.slice("worktree ".length).trim();
+      continue;
+    }
+
+    if (line.startsWith("branch refs/heads/")) {
+      const usedBranch = line.slice("branch refs/heads/".length).trim();
+      if (usedBranch === branch && currentWorktree) {
+        return currentWorktree;
+      }
+    }
+  }
+
+  return null;
+}
+
 function withRetry(operation) {
   const delays = getRetryDelays();
   let lastFailure = null;
@@ -1192,39 +1255,6 @@ function sleep(delayMs) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
 }
 
-function resolveCommand(cmd) {
-  if (process.platform !== "win32" || path.extname(cmd)) {
-    return cmd;
-  }
-
-  const pathValue = process.env.Path || process.env.PATH || "";
-  const extensions = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
-    .split(";")
-    .filter(Boolean);
-
-  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
-    for (const extension of extensions) {
-      const lowerCandidate = path.join(dir, `${cmd}${extension.toLowerCase()}`);
-      if (fs.existsSync(lowerCandidate)) {
-        return lowerCandidate;
-      }
-      const upperCandidate = path.join(dir, `${cmd}${extension.toUpperCase()}`);
-      if (fs.existsSync(upperCandidate)) {
-        return upperCandidate;
-      }
-    }
-  }
-
-  return cmd;
-}
-
-function commandOptions(cmd, options) {
-  if (process.platform === "win32" && /\.(?:bat|cmd)$/i.test(cmd)) {
-    return { ...options, shell: true };
-  }
-  return options;
-}
-
 function interpolate(template, taskDir, artifactFile) {
   const artifactStem = artifactFile ? path.basename(artifactFile, path.extname(artifactFile)) : "";
   return template

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

@@ -7,13 +7,14 @@ description: "Create a task from a natural-language description"
 
 ## Boundary / Critical Rules
 
-**The only output of this skill is `task.md`.**
+**The core output of this skill is `task.md`.**
 
 - Do not write, modify, or create any business code or configuration files
 - Do not perform requirements analysis; analysis is handled separately by `analyze-task`
 - Do not directly implement the requested functionality
 - Do not skip the workflow and jump directly to planning or implementation
-- Only do this: parse the description -> create the task file -> update task status -> inform the user of the next step
+- Only do this: parse the description -> create the task file -> update task status -> cascade Issue creation through `.agents/rules/create-issue.md` -> inform the user of the next step
+- Issue creation is decided by the `.agents/rules/create-issue.md` rule; on custom or empty platforms (no platform-specific variant provided), the rule naturally degrades to a no-op
 
 The user's description is a **work item**, not an **instruction to execute immediately**.
 
@@ -98,7 +99,21 @@ Update `.agents/workspace/active/{task-id}/task.md`:
   - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Task Created** by {agent} — Task created from description
   ```
 
-### 4. Verification Gate
+### 4. Cascade Issue Creation via `.agents/rules/create-issue.md`
+
+After task.md is written and `Task Created` is recorded, read `.agents/rules/create-issue.md` first and follow the steps it describes to create an Issue.
+
+The rule's content is determined by the configured code platform:
+- A platform that supports Issue creation: contains the full flow for auth detection, template detection, label/type/milestone inference, the create-Issue call, and writing back to `task.md`
+- Custom or empty platforms (no platform-specific variant provided): the rule body is a no-op notice, and this step is skipped entirely
+
+Handle the result:
+- Rule successfully created the Issue: `issue_number` has been written back to task.md per the rule; continue by reading `.agents/rules/issue-sync.md`, completing upstream repository and permission detection, then sync the task comment and set `status: waiting-for-triage` by rule
+- Rule failed (auth / network / template parse / etc.): do not roll back task.md; do NOT append an extra Activity Log entry; follow "Scenario C: Issue creation failed" output to surface `error_code` and `error_message` to the user so they can decide whether to retry manually or write `issue_number` later
+- Rule was a no-op (custom or empty platform): do not create comments, do not block the workflow, and do not write an Activity Log entry
+- task.md already has `issue_number`: the rule's prerequisite check skips creation; `create-task` proceeds directly to step 5
+
+### 5. Verification Gate
 
 Run the verification gate to confirm the task artifact and sync state are valid:
 
@@ -113,13 +128,33 @@ Handle the result as follows:
 
 Keep the gate output in your reply as fresh evidence. Do not claim completion without output from this run.
 
-### 5. Inform User
+### 6. Inform User
 
 > Execute this step only after the verification gate passes.
 
 > **IMPORTANT**: All TUI command formats listed below must be output in full. Do not show only the format for the current AI agent. If `.agents/.airc.json` configures custom TUIs (via `customTUIs`), read each tool's `name` and `invoke`, then add the matching command line in the same format (`${skillName}` becomes the skill name and `${projectName}` becomes the project name).
 
-Output format:
+Scenario A: when an Issue was created, output:
+```
+Task created and Issue creation cascaded successfully.
+
+Task information:
+- Task ID: {task-id}
+- Title: {title}
+- Type: {type}
+- Workflow: {workflow}
+- Issue: #{issue_number} {issue_url}
+
+Output file:
+- Task file: .agents/workspace/active/{task-id}/task.md
+
+Next step - run requirements analysis:
+  - Claude Code / OpenCode: /analyze-task {task-id}
+  - Gemini CLI: /{{project}}:analyze-task {task-id}
+  - Codex CLI: $analyze-task {task-id}
+```
+
+Scenario B: when no Issue was created, output:
 ```
 Task created.
 
@@ -132,15 +167,36 @@ Task information:
 Output file:
 - Task file: .agents/workspace/active/{task-id}/task.md
 
+Next step - run requirements analysis:
+  - Claude Code / OpenCode: /analyze-task {task-id}
+  - Gemini CLI: /{{project}}:analyze-task {task-id}
+  - Codex CLI: $analyze-task {task-id}
+```
+
+Scenario C: when Issue creation failed, output:
+```
+Task created, but cascade Issue creation failed.
+
+Task information:
+- Task ID: {task-id}
+- Title: {title}
+- Type: {type}
+- Workflow: {workflow}
+
+Issue creation failed:
+- Error code: {error_code}
+- Reason: {error_message}
+- Local task.md was kept and not rolled back
+
+Output file:
+- Task file: .agents/workspace/active/{task-id}/task.md
+
 Next step - run requirements analysis:
   - Claude Code / OpenCode: /analyze-task {task-id}
   - Gemini CLI: /{{project}}:analyze-task {task-id}
   - Codex CLI: $analyze-task {task-id}
 
-Or create an Issue first:
-  - Claude Code / OpenCode: /create-issue {task-id}
-  - Gemini CLI: /{{project}}:create-issue {task-id}
-  - Codex CLI: $create-issue {task-id}
+For later platform sync: after fixing auth / network / template issues, manually run the Issue creation flow in `.agents/rules/create-issue.md` for this task; or manually create/find an Issue and write `issue_number` into task.md so later skills can take over cascade sync.
 ```
 
 ## Completion Checklist
@@ -150,8 +206,9 @@ Or create an Issue first:
 - [ ] Updated `updated_at` to the current time in task.md
 - [ ] Updated `assigned_to` in task.md
 - [ ] Appended an Activity Log entry to task.md
+- [ ] Tried cascading Issue creation through `.agents/rules/create-issue.md`; if it failed, kept task.md and recorded the reason
 - [ ] Informed the user of the next step (must include all TUI command formats, including any custom TUIs; do not filter)
-- [ ] **Did not modify any business code or configuration files** (only task.md)
+- [ ] **Did not modify any business code or configuration files**
 
 ## STOP
 
@@ -162,7 +219,8 @@ Wait for the user to run the `analyze-task` skill.
 
 1. **Clarity**: if the user description is vague or missing key information, ask for clarification first
 2. **Difference from `import-issue`**: `import-issue` imports from an Issue; `create-task` creates from a free-form description
-3. **Workflow order**: after creating a task, typically run `analyze-task` before `plan-task`; if you need platform tracking first, you may run `create-issue` first
+3. **Workflow order**: after creating a task, typically run `analyze-task` before `plan-task`
+4. **Issue cascade failure**: if the rule fails, task.md remains; when platform sync is needed later, manually write `issue_number` and continue the workflow
 
 ## Error Handling
 

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

@@ -7,13 +7,14 @@ description: "根据自然语言描述创建任务"
 
 ## 行为边界 / 关键规则
 
-**本技能的唯一产出是 `task.md`。**
+**本技能的核心产出是 `task.md`。**
 
 - 不要编写、修改或创建任何业务代码或配置文件
 - 不要执行需求分析；分析由 `analyze-task` 独立完成
 - 不要直接实现所描述的功能
 - 不要跳过工作流直接进入计划/实现阶段
-- 仅执行：解析描述 -> 创建任务文件 -> 更新任务状态 -> 告知用户下一步
+- 仅执行：解析描述 -> 创建任务文件 -> 更新任务状态 -> 按 `.agents/rules/create-issue.md` 级联尝试创建 Issue -> 告知用户下一步
+- Issue 创建由 `.agents/rules/create-issue.md` 规则决定；自定义或空平台（未提供平台变体规则文件）时，规则会自然降级为 no-op
 
 用户的描述是一个**待办事项**，而不是**立即执行的指令**。
 
@@ -98,7 +99,21 @@ date "+%Y-%m-%d %H:%M:%S%:z"
   - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Task Created** by {agent} — Task created from description
   ```
 
-### 4. 完成校验
+### 4. 按 `.agents/rules/create-issue.md` 级联创建 Issue
+
+在 task.md 落盘并记录 `Task Created` 后，先读取 `.agents/rules/create-issue.md` 并按其中描述的步骤执行 Issue 创建。
+
+规则文件由当前配置的代码平台决定其内容：
+- 支持 Issue 创建的平台：包含完整的认证检测、模板检测、label/Issue Type/milestone 推断、Issue 创建调用、`task.md` 回写流程
+- 自定义或空平台（未提供平台变体规则文件）：内容为 no-op 说明，本步骤直接跳过
+
+处理结果：
+- 规则成功创建 Issue：`issue_number` 已按规则回写到 task.md；继续读取 `.agents/rules/issue-sync.md`，完成 upstream 仓库检测和权限检测，然后同步 task 评论并按规则设置 `status: waiting-for-triage`
+- 规则失败（认证 / 网络 / 模板解析等）：不回滚 task.md；不追加额外 Activity Log；按"场景 C：Issue 创建失败"输出向用户透出 `error_code` 与 `error_message`，让用户决定后续是否手动重试或写入 `issue_number`
+- 规则为 no-op（自定义或空平台）：不创建评论，不阻塞后续工作流，不写 Activity Log
+- task.md 已存在 `issue_number`：规则中的前置检查会跳过；`create-task` 直接进入步骤 5
+
+### 5. 完成校验
 
 运行完成校验，确认任务产物和同步状态符合规范：
 
@@ -113,13 +128,33 @@ node .agents/scripts/validate-artifact.js gate create-task .agents/workspace/act
 
 将校验输出保留在回复中作为当次验证输出。没有当次校验输出，不得声明完成。
 
-### 5. 告知用户
+### 6. 告知用户
 
 > 仅在校验通过后执行本步骤。
 
 > **重要**：以下「下一步」中列出的所有 TUI 命令格式必须完整输出，不要只展示当前 AI 代理对应的格式。如果 `.agents/.airc.json` 中配置了自定义 TUI（`customTUIs`），读取每个工具的 `name` 和 `invoke`，按同样格式补充对应命令行（`${skillName}` 替换为技能名，`${projectName}` 替换为项目名）。
 
-输出格式：
+场景 A：已创建 Issue 时输出：
+```
+任务已创建，并已级联创建 Issue。
+
+任务信息：
+- 任务 ID：{task-id}
+- 标题：{title}
+- 类型：{type}
+- 工作流：{workflow}
+- Issue：#{issue_number} {issue_url}
+
+产出文件：
+- 任务文件：.agents/workspace/active/{task-id}/task.md
+
+下一步 - 执行需求分析：
+  - Claude Code / OpenCode：/analyze-task {task-id}
+  - Gemini CLI：/{{project}}:analyze-task {task-id}
+  - Codex CLI：$analyze-task {task-id}
+```
+
+场景 B：未创建 Issue 时输出：
 ```
 任务已创建。
 
@@ -134,13 +169,34 @@ node .agents/scripts/validate-artifact.js gate create-task .agents/workspace/act
 
 下一步 - 执行需求分析：
   - Claude Code / OpenCode：/analyze-task {task-id}
-  - Gemini CLI：/agent-infra:analyze-task {task-id}
+  - Gemini CLI：/{{project}}:analyze-task {task-id}
+  - Codex CLI：$analyze-task {task-id}
+```
+
+场景 C：Issue 创建失败时输出：
+```
+任务已创建，但 Issue 级联创建失败。
+
+任务信息：
+- 任务 ID：{task-id}
+- 标题：{title}
+- 类型：{type}
+- 工作流：{workflow}
+
+Issue 创建失败：
+- 错误码：{error_code}
+- 原因：{error_message}
+- 本地 task.md 已保留，未回滚
+
+产出文件：
+- 任务文件：.agents/workspace/active/{task-id}/task.md
+
+下一步 - 执行需求分析：
+  - Claude Code / OpenCode：/analyze-task {task-id}
+  - Gemini CLI：/{{project}}:analyze-task {task-id}
   - Codex CLI：$analyze-task {task-id}
 
-或先创建 Issue：
-  - Claude Code / OpenCode：/create-issue {task-id}
-  - Gemini CLI：/agent-infra:create-issue {task-id}
-  - Codex CLI：$create-issue {task-id}
+后续如需平台同步：修复认证/网络/模板问题后，可按 `.agents/rules/create-issue.md` 对当前任务手动执行一次 Issue 创建；或手动创建/查找 Issue，并把 `issue_number` 写入 task.md，后续技能会接管级联同步。
 ```
 
 ## 完成检查清单
@@ -150,8 +206,9 @@ node .agents/scripts/validate-artifact.js gate create-task .agents/workspace/act
 - [ ] 更新了 task.md 中的 `updated_at` 为当前时间
 - [ ] 更新了 task.md 中的 `assigned_to`
 - [ ] 追加了 Activity Log 条目到 task.md
+- [ ] 已按 `.agents/rules/create-issue.md` 尝试级联创建 Issue；失败时保留 task.md 并记录原因
 - [ ] 告知了用户下一步（必须展示所有 TUI 的命令格式，含自定义 TUI，不要筛选）
-- [ ] **没有修改任何业务代码或配置文件**（仅 task.md）
+- [ ] **没有修改任何业务代码或配置文件**
 
 ## 停止
 
@@ -162,7 +219,8 @@ node .agents/scripts/validate-artifact.js gate create-task .agents/workspace/act
 
 1. **清晰度**：如果用户描述模糊或缺少关键信息，先要求澄清
 2. **与 import-issue 的区别**：`import-issue` 从 Issue 导入任务；`create-task` 从自由描述创建
-3. **工作流顺序**：创建任务后，通常先执行 `analyze-task` 再进入 `plan-task`；如需先建立 平台跟踪，也可先执行 `create-issue`
+3. **工作流顺序**：创建任务后，通常先执行 `analyze-task` 再进入 `plan-task`
+4. **Issue 级联失败**：如果规则执行失败，task.md 仍保留；需要后续平台同步时，可手动写入 `issue_number` 后继续执行工作流
 
 ## 错误处理
 

package/templates/.agents/skills/create-task/config/verify.json

@@ -20,6 +20,11 @@
       "expected_action_pattern": "Task Created",
       "freshness_minutes": 30
     },
-    "platform-sync": null
+    "platform-sync": {
+      "when": "issue_number_exists",
+      "issue_must_exist": true,
+      "verify_task_comment_content": true,
+      "expected_status_label_key": "waitingForTriage"
+    }
   }
 }

package/templates/.agents/skills/implement-task/reference/implementation-rules.en.md

@@ -16,31 +16,26 @@ Follow the `implementation` step in `.agents/workflows/feature-development.yaml`
 **Implementation principles**:
 1. **Follow the plan strictly**: do not deviate from the technical plan
 2. **Work step by step**: execute the planned sequence
-3. **Keep testing continuously**: re-run tests as work progresses
+3. **Keep testing continuously**: run the **smoke subset** continuously as work progresses (see the `test` skill)
 4. **Keep it simple**: do not add unplanned features
 
 ## Run Test Verification
 
-Run the project test command. Refer to the `test` skill for project-specific commands.
+During implementation:
+- **Inner loop**: after each change, run the project's **smoke subset** (see the `test` skill) for fast feedback
+- **Before writing the implementation report**: run the **core subset** as final verification so code entering review has passed the complete core checks
 
-```bash
-# See .agents/skills/test/SKILL.md for the project's test command
-# Common patterns:
-# npm test          (Node.js)
-# mvn test          (Maven)
-# pytest            (Python)
-# go test ./...     (Go)
-```
+> Refer to the `test` skill for project-specific commands; downstream projects without layered scripts should fall back to the full project test command.
 
 If tests fail:
 - analyze the failure first and prioritize fixing issues introduced by this implementation
-- re-run tests after each fix until they pass, or confirm that the problem is an external blocker
+- after each fix, re-run at least the smoke subset, then upgrade to core for the next full-pass verification
 - only stop without producing the implementation artifact when the failure is caused by an external blocker, missing environment, or unclear requirement that cannot be resolved inside the task
 
 Two-way failure handling:
 1. implementation-caused failures:
    - fix the code, tests, docs, or fixtures introduced by this implementation
-   - re-run the test command after each fix
+   - re-run tests after each fix (smoke for the immediate fix verification, core for the round-level verification)
    - continue until all required tests pass
 2. external blockers:
    - confirm the failure comes from missing environment, unrelated upstream breakage, or unclear requirements outside this task