@fitlab-ai/agent-infra 0.7.1 → 0.7.2

package/templates/.agents/rules/task-short-id.zh-CN.md

@@ -1,25 +1,27 @@
 # 任务短号
 
-短号让所有 SKILL 在 active 任务生命周期内可以用 `#NN` 替代完整的 22 字符
-`TASK-YYYYMMDD-HHMMSS`。
+短号让所有 SKILL 在 active 任务生命周期内可以用 `#NN` 或裸数字 `N`（推荐）替代
+完整的 22 字符 `TASK-YYYYMMDD-HHMMSS`。
 
 ## 语法
 
-- 格式：`^#\d{shortIdLength}$`（**零填充到固定宽度**；默认 `shortIdLength=2` 时
-  形如 `#01`、`#07`、`#42`）。
-- **必须**零填充到 `shortIdLength` 位（默认 2 位：`#1` 视为格式错误，应输入
-  `#01`）。这是为了视觉对齐与盲打体验。
+- 字面接受两种等价形式：
+  - **裸数字 `N`**（推荐，无需 shell 引号）：如 `1`、`7`、`42`。
+  - **`#`-前缀 `#N` / `#NN`**（也接受；但 bash 需 `'...'` 引号）：如 `#1`、`#01`、`#42`。
+- 解析规则：去前导零后取数值 `n`，若 `n == 0` 报错（保留）；若 `n > 10^shortIdLength - 1`
+  报错（超容量）；否则归一化为 `#${n.padStart(shortIdLength, '0')}`，作为注册表 key。
+- 默认 `shortIdLength=2` 时容量 `n ∈ [1, 99]`，注册表 key 形如 `01`、`07`、`42`。
 - `#00`（或 `shortIdLength=1` 时 `#0`）保留、永不分配；纯数字、不引入字母。
-- 完整 `TASK-…` 入参在所有路径下行为与现状等价；`#NN` 只是别名，不是持久化任务 ID。
+- 完整 `TASK-…` 入参在所有路径下行为与现状等价；`#NN` / 裸数字只是别名，不是持久化任务 ID。
 
 ## 生命周期
 
-| 动作      | 触发时机                                                                                     | 注册表 / task.md 效应                                            |
+| 动作      | 触发时机                                                                                     | 注册表效应                                                       |
 |-----------|---------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-| alloc     | `create-task`、`import-issue`、`import-codescan`、`import-dependabot`                       | 分配最小可用 `#NN`，写入 task.md 的 `short_id` 字段。              |
+| alloc     | `create-task`、`import-issue`、`import-codescan`、`import-dependabot`                       | 分配最小可用 `#NN`，写入注册表。                                  |
 | resolve   | 生命周期 SKILL（`analyze-task` / `plan-task` / `code-task` / `review-*` / `commit` / …）    | `#NN` → 完整 task id 查询，不分配。                              |
-| release   | `complete-task`、`cancel-task`、`block-task`、`close-codescan`、`close-dependabot`          | 从注册表移除；task.md 的 `short_id` 字段保留作为历史值。          |
-| re-alloc  | `restore-task`                                                                              | 重新分配（可能与历史不同），写入注册表与 task.md。               |
+| release   | `complete-task`、`cancel-task`、`block-task`、`close-codescan`、`close-dependabot`          | 从注册表移除。                                                   |
+| re-alloc  | `restore-task`                                                                              | 重新分配（可能与历史不同），写入注册表。                         |
 
 短号仅在任务处于 `.agents/workspace/active/` 期间有效；任务移动到
 `completed/` / `blocked/` / `archive/` 后短号立即释放，可被新任务复用。
@@ -44,21 +46,20 @@
 | 入口                                                       | 注册表命中            | 注册表未命中                                            |
 |-----------------------------------------------------------|----------------------|--------------------------------------------------------|
 | SKILL 入参解析器（生命周期 SKILL）                          | 解析为完整 task id    | **严格报错** —— 短号不存在 / 格式错误                  |
-| `ai sandbox enter '#NN'` / `ai sandbox exec '#NN' …`      | 解析为完整 task id    | 回退到 running sandbox 的 ls 行号语义（保留 #414 行为）|
+| `ai sandbox exec <N \| '#N'>` / `ai sandbox create <N \| '#N'>`           | 解析为完整 task id 后查 task.md 取 `branch` | **严格报错** —— 不再回退到 ls 行号或字面分支名；提示用任务短号 / `TASK-id` / 分支名 |
 
-`list --verify` 严格只读：报告 active 目录 / 注册表 / 各 task.md 的 `short_id`
-三者差异，但不修改任何状态。
+`list --verify` 严格只读：报告 active 目录 / 注册表 两者差异，但不修改任何状态。
 
 ## SKILL 入参解析
 
 任意 SKILL（含 alloc / resolve / release / re-alloc 四类生命周期入口）在收到
 `{task-id}` 入参后，必须按以下契约处理：
 
-1. 如果 `{task-id}` 字面以 `#` 开头：
+1. 如果 `{task-id}` 字面匹配 `^[#]?[0-9]+$`（裸数字 `N` 或 `#`-前缀 `#N`）：
 
 ```bash
-if [[ "{task-id}" == "#"* ]]; then
-  # 脚本本身已输出完整错误（含「expected #NN (N-digit zero-padded; e.g. '#01')」）；
+if [[ "{task-id}" =~ ^[#]?[0-9]+$ ]]; then
+  # 脚本本身已输出完整错误（含 reserved / exceeds shortIdLength capacity 等场景）；
   # 调用方只需透传退出码
   task_id=$(node .agents/scripts/task-short-id.js resolve "{task-id}") || exit 1
 else
@@ -71,54 +72,34 @@ fi
 
 ## 存储位置
 
-短号系统跨两处持久化状态，二者在稳态时一一对应：
-
-| 位置 | 写入时机 | 读取时机 | 删除时机 |
-|---|---|---|---|
-| `.agents/workspace/active/.short-ids.json`（注册表） | `alloc` / 冷启动迁移 | `resolve` 唯一权威源 / `list` / `list --verify` | `release` / 冷启动 stale 清理 |
-| 各 task.md frontmatter 的 `short_id` 字段 | `alloc` / 冷启动迁移 | `list --verify`（比对一致性） | **永不删除**（归档后保留为历史值） |
-
-**注册表**：
+短号是纯本地状态，唯一持久化在注册表 `.agents/workspace/active/.short-ids.json`，task.md 不持有短号：
 
 - 路径：`<repo-root>/.agents/workspace/active/.short-ids.json`
 - Schema：`{ "version": 1, "ids": { "01": "TASK-20260609-192644", "02": "TASK-…" } }`
 - key 是零填充到 `task.shortIdLength` 位的字符串，value 是完整 `TASK-…` task id
 - 自动 git ignore（active 工作区整体 ignore；无需新增 ignore 条目）
-- 首次 `alloc` / `resolve` 时按需自动创建；不存在时按空注册表处理
-
-**task.md `short_id` 字段**：
+- 首次 `alloc` 时按需自动创建；不存在时按空注册表处理
+- 短号只由显式 `alloc`（`create-task` / `import-*` / `restore-task`）分配；`resolve` / `list` / `release` 不分配，仅在执行时自动清理指向非 active 任务的 stale entry
+- 归档（complete-task / cancel-task / block-task / close-*）后注册表 entry 立即删除，短号可被新任务复用；归档后引用任务一律用完整 `TASK-…` id
 
-- 在 frontmatter 中、紧跟 `id` 字段之后；格式 `short_id: #01`
-- 与注册表 key 字面一致（含 `#` 前缀）
-- 归档（complete-task / cancel-task / block-task / close-*）后：注册表 entry 立即
-  删除（短号可被新任务复用），但 task.md `short_id` 字段保留作为历史值。解析器
-  只信任注册表
-- 冷启动迁移：升级 agent-infra 后首次 alloc / resolve 路径会扫描所有 active
-  目录并为缺字段的 task.md 补发短号；补发受字段保护约束（不刷新
-  `updated_at` / `agent_infra_version`、不追加 Activity Log）
-
-`resolve('#NN')` 工作流：① 校验入参严格匹配 `^#\d{shortIdLength}$` → ② 直接以
-`NN` 作为 key 查注册表 `ids` → ③ 命中返回完整 task id，未命中按 `list --verify`
-给出修复指引退出 1。
+`resolve(<N|'#N'>)` 工作流：① 校验入参匹配 `^[#]?[0-9]+$` → ② 去前导零取
+数值 `n`，按 `n` 是否 `== 0`（保留）/ `> 10^shortIdLength - 1`（超容量）/
+正常 三类处理 → ③ 正常时以 `n.padStart(shortIdLength, '0')` 作为 key 查
+注册表 `ids` → ④ 命中返回完整 task id，未命中按 `list --verify` 给出修复指引退出 1。
 
 ## 错误场景
 
-- **短号不存在**：注册表中无 `#NN`。可能是任务已归档（短号已释放）或输入错误。
+- **短号不存在**：注册表中无对应 key。可能是任务已归档（短号已释放）或输入错误。退出码 1。
 - **注册表损坏**（同一 taskId 出现多次或 JSON 无法解析）：退出码 2，需人工处理。
-- **参数格式错误**（如 `#00`、`#abc`、`#`、`#1` 当 `shortIdLength=2` 时）：退出码 1。
+- **保留键**：解析后 `n == 0`（输入如 `0`、`#0`、`#00`）。退出码 1。
+- **超容量**：解析后 `n > 10^shortIdLength - 1`（如 `shortIdLength=2` 下 `100` 或 `#100`）。退出码 1。
+- **参数格式错误**：入参既不是 `^[#]?[0-9]+$` 也不是 `TASK-id`（如 `#abc`、`#`、`5.5`）。退出码 1。
 
 ## 跨 TUI 引号要求
 
-bash 中 `#` 是注释起始符，必须单引号：`ai sandbox exec '#03' 'npm test'`。
-Claude Code / Codex / Gemini CLI / OpenCode 在加引号时都能把 `#NN` 字面传递到
-SKILL 的 `ARGUMENTS`。
-
-## 冷启动迁移
-
-升级 agent-infra 后，首次 `alloc` / `resolve` 调用会触发冷启动迁移：
+裸数字 `N` 在所有 shell 与 TUI 中都安全无需引号，推荐写法：
+`ai sandbox exec 11 'npm test'`、`/review-analysis 11`。
 
-- 所有 active task.md 缺 `short_id` 字段时自动补发并回写（仅修改 `short_id`
-  一行，不刷新 `updated_at` / `agent_infra_version`，不追加 Activity Log）。
-- 若 active 任务总数超过 `shortIdLength` 容量，**在任何写入之前**报错退出 2。
-- 若 task.md 写入中途失败，`tx.commit()` 按缓存的原内容回滚所有已写文件（含
-  `mtime` / `atime` 恢复）。
+`#N` / `#NN` 写法也接受；但 bash 中 `#` 是注释起始符，必须单引号：
+`ai sandbox exec '#03' 'npm test'`。Claude Code / Codex / Gemini CLI / OpenCode
+在加引号时都能把 `#NN` 字面传递到 SKILL 的 `ARGUMENTS`。

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

@@ -5,6 +5,7 @@ import spawn from "cross-spawn";
 
 const CHECK_TYPE = "platform-sync";
 const DEFAULT_RETRY_DELAYS_MS = [3000, 10000];
+const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
 const FRONTMATTER_FIELD_MAP = {
   priority: "Priority",
   effort: "Effort",
@@ -811,6 +812,22 @@ function checkMilestone(context, remoteData) {
     );
   }
 
+  if (context.config.verify_milestone_specific) {
+    const issueTitle = remoteData.issue.milestone.title;
+    if (VERSION_LINE_REGEX.test(issueTitle)) {
+      return failResult(CHECK_TYPE,
+        `Issue #${context.issueNumber} milestone '${issueTitle}' is a release line; narrow to a specific version (e.g. ${issueTitle.replace(/\.x$/, ".N")}) before continuing`,
+        "check_failed"
+      );
+    }
+    if (context.prNumber && remoteData.prMilestone?.title && VERSION_LINE_REGEX.test(remoteData.prMilestone.title)) {
+      return failResult(CHECK_TYPE,
+        `PR #${context.prNumber} milestone '${remoteData.prMilestone.title}' is a release line; narrow to a specific version before continuing`,
+        "check_failed"
+      );
+    }
+  }
+
   return null;
 }
 

package/templates/.agents/scripts/task-short-id.js

@@ -32,11 +32,11 @@ function usage() {
     "Usage: task-short-id.js <subcommand> [args]",
     "",
     "Subcommands:",
-    "  alloc <task-id>      Allocate short id for a task; writes registry + short_id to task.md",
+    "  alloc <task-id>      Allocate short id for a task in the registry",
     "  release <task-id>    Release short id (idempotent; exit 0 if not present)",
     "  resolve <#N>         Resolve short id to full task id",
     "  list                 Print registry JSON",
-    "  list --verify        Read-only check; exit 1 if active dir / registry / task.md disagree",
+    "  list --verify        Read-only check; exit 1 if active dir / registry disagree",
     "",
     "Options:",
     "  --active-dir <path>  Override active dir (default: <repo>/.agents/workspace/active)",
@@ -161,17 +161,6 @@ function withRegistryLock(activeDir, fn, timeoutMs = DEFAULT_LOCK_TIMEOUT_MS) {
   }
 }
 
-function writeTaskMdShortId(taskMdPath, shortId) {
-  const content = fs.readFileSync(taskMdPath, "utf8");
-  let updated;
-  if (/^short_id:.*$/m.test(content)) {
-    updated = content.replace(/^short_id:.*$/m, `short_id: ${shortId}`);
-  } else {
-    updated = content.replace(/^(id:.*)$/m, `$1\nshort_id: ${shortId}`);
-  }
-  fs.writeFileSync(taskMdPath, updated);
-}
-
 function padShortId(n, shortIdLength) {
   return String(n).padStart(shortIdLength, "0");
 }
@@ -185,24 +174,34 @@ function allocateMinFreeInt(registry, shortIdLength) {
 }
 
 function parseShortIdArg(arg, shortIdLength) {
-  const re = new RegExp(`^#\\d{${shortIdLength}}$`);
-  if (!re.test(arg)) {
-    const example =
-      shortIdLength === 1 ? "'#1'" : shortIdLength === 2 ? "'#01'" : `'#${"0".repeat(shortIdLength - 1)}1'`;
+  const L = shortIdLength;
+  const max = Math.pow(10, L) - 1;
+  // Accept bare numeric or '#'-prefixed; canonicalize to zero-padded key.
+  // Bare numeric is the recommended form (no shell quoting needed).
+  const m = /^#?(\d+)$/.exec(arg);
+  if (!m) {
     writeStderr(
       `Error: invalid short id format '${arg}', ` +
-        `expected #${"N".repeat(shortIdLength)} (${shortIdLength}-digit zero-padded; e.g. ${example})\n`
+        `expected bare digits (recommended) or '#'-prefixed digits; ` +
+        `e.g. '11' or '#11' (shortIdLength=${L}, max=${max})\n`
+    );
+    process.exit(1);
+  }
+  const n = Number(m[1]);
+  if (n === 0) {
+    writeStderr(
+      `Error: short id '${arg}' is invalid (#${"0".repeat(L)} is reserved)\n`
     );
     process.exit(1);
   }
-  const key = arg.slice(1);
-  if (Number(key) === 0) {
+  if (n > max) {
     writeStderr(
-      `Error: short id '${arg}' is invalid (#${"0".repeat(shortIdLength)} is reserved)\n`
+      `Error: short id ${n} exceeds shortIdLength=${L} capacity (max=${max}); ` +
+        `archive tasks or raise task.shortIdLength in .agents/.airc.json\n`
     );
     process.exit(1);
   }
-  return key;
+  return String(n).padStart(L, "0");
 }
 
 function planTransaction(registry, activeDir, shortIdLength) {
@@ -216,7 +215,7 @@ function planTransaction(registry, activeDir, shortIdLength) {
       .filter((d) => fs.existsSync(path.join(activeDir, d, "task.md")))
   );
 
-  // A2: stale entries
+  // A2: stale entries (registry points at a task no longer active)
   const pendingRegistryDeletes = [];
   for (const [key, taskId] of Object.entries(registry.ids)) {
     if (!activeTaskIds.has(taskId)) pendingRegistryDeletes.push(key);
@@ -238,106 +237,17 @@ function planTransaction(registry, activeDir, shortIdLength) {
     taskIdToKey.set(taskId, key);
   }
 
-  // A4: classify each active task
+  // The registry is the sole source of truth: short ids are allocated only by
+  // explicit `alloc` (planAlloc), never inferred from task.md or auto-allocated
+  // for active tasks. Read paths (resolve/list) only run stale cleanup (A2).
   const plannedRegistryWrites = [];
-  const plannedTaskMdWrites = [];
-  const pendingAlloc = [];
-
-  for (const taskId of activeTaskIds) {
-    const taskMdPath = path.join(activeDir, taskId, "task.md");
-    const originalStat = fs.statSync(taskMdPath);
-    const originalContent = fs.readFileSync(taskMdPath, "utf8");
-    const existing = originalContent.match(/^short_id:\s*(#\d+)\s*$/m);
-
-    if (existing) {
-      const declared = existing[1];
-      const n = declared.slice(1);
-      if (projectedIds[n] === taskId) continue; // 4a
-      if (taskIdToKey.has(taskId)) {
-        const registryKey = taskIdToKey.get(taskId);
-        writeStderr(
-          `Inconsistent: task ${taskId} declares ${declared} but registry holds it at #${registryKey}\n`
-        );
-        process.exit(2);
-      }
-      if (projectedIds[n] && projectedIds[n] !== taskId) {
-        writeStderr(
-          `Inconsistent: task ${taskId} declares ${declared} but registry maps ${declared} to ${projectedIds[n]}\n`
-        );
-        process.exit(2);
-      }
-      // 4d
-      plannedRegistryWrites.push({ key: n, taskId });
-      projectedIds[n] = taskId;
-      taskIdToKey.set(taskId, n);
-      continue;
-    }
-
-    if (taskIdToKey.has(taskId)) {
-      // 4e
-      const registryKey = taskIdToKey.get(taskId);
-      plannedTaskMdWrites.push({
-        taskMdPath,
-        originalContent,
-        originalAtime: originalStat.atime,
-        originalMtime: originalStat.mtime,
-        shortId: `#${registryKey}`,
-        kind: "4e"
-      });
-      continue;
-    }
-
-    // 4f: deferred
-    pendingAlloc.push({
-      taskId,
-      taskMdPath,
-      originalContent,
-      originalAtime: originalStat.atime,
-      originalMtime: originalStat.mtime
-    });
-  }
-
-  // A5: capacity pre-check
-  const availableSlots = maxN - Object.keys(projectedIds).length;
-  if (pendingAlloc.length > availableSlots) {
-    writeStderr(
-      `Error: cold-start migration needs ${pendingAlloc.length} short id(s) but only ${availableSlots} ` +
-        `slot(s) available (capacity=${maxN}, in-use after stale-cleanup=${Object.keys(projectedIds).length}). ` +
-        `Archive some active tasks (complete-task / cancel-task / block-task) ` +
-        `or raise task.shortIdLength in .agents/.airc.json.\n`
-    );
-    process.exit(2);
-  }
-
-  pendingAlloc.sort((a, b) => a.taskId.localeCompare(b.taskId));
-
-  for (const item of pendingAlloc) {
-    const n = allocateMinFreeInt({ ids: projectedIds }, shortIdLength);
-    if (n === null) {
-      throw new Error("Internal invariant: pendingAlloc capacity check failed");
-    }
-    const key = padShortId(n, shortIdLength);
-    projectedIds[key] = item.taskId;
-    taskIdToKey.set(item.taskId, key);
-    plannedRegistryWrites.push({ key, taskId: item.taskId });
-    plannedTaskMdWrites.push({
-      taskMdPath: item.taskMdPath,
-      originalContent: item.originalContent,
-      originalAtime: item.originalAtime,
-      originalMtime: item.originalMtime,
-      shortId: `#${key}`,
-      kind: "4f"
-    });
-  }
 
-  // Build transaction object
   const tx = {
     _registry: registry,
     _activeDir: activeDir,
     _registrySnapshot: { ...registry.ids },
     _pendingRegistryDeletes: pendingRegistryDeletes,
     _plannedRegistryWrites: plannedRegistryWrites,
-    _plannedTaskMdWrites: plannedTaskMdWrites,
     _projectedIds: projectedIds,
     _taskIdToKey: taskIdToKey,
     _shortIdLength: shortIdLength,
@@ -363,20 +273,6 @@ function planTransaction(registry, activeDir, shortIdLength) {
       this._projectedIds[key] = taskId;
       this._taskIdToKey.set(taskId, key);
       this._plannedRegistryWrites.push({ key, taskId });
-      const originalStat = fs.statSync(taskMdPath);
-      const originalContent = fs.readFileSync(taskMdPath, "utf8");
-      // If task.md already declares the same short id (e.g. R-alloc replay), skip writing.
-      const existing = originalContent.match(/^short_id:\s*(#\d+)\s*$/m);
-      if (!existing || existing[1] !== `#${key}`) {
-        this._plannedTaskMdWrites.push({
-          taskMdPath,
-          originalContent,
-          originalAtime: originalStat.atime,
-          originalMtime: originalStat.mtime,
-          shortId: `#${key}`,
-          kind: "caller-alloc"
-        });
-      }
       return key;  // zero-padded; matches registry key
     },
 
@@ -386,54 +282,22 @@ function planTransaction(registry, activeDir, shortIdLength) {
       this._plannedRegistryWrites = this._plannedRegistryWrites.filter(
         (w) => w.taskId !== taskId
       );
-      this._plannedTaskMdWrites = this._plannedTaskMdWrites.filter(
-        (w) => path.basename(path.dirname(w.taskMdPath)) !== taskId
-      );
       this._pendingRegistryDeletes.push(key);
       delete this._projectedIds[key];
       this._taskIdToKey.delete(taskId);
     },
 
     commit(registryPath) {
-      // B1: apply registry mutation in memory
+      // Apply registry mutation in memory, then persist atomically.
       for (const key of this._pendingRegistryDeletes) delete this._registry.ids[key];
       for (const { key, taskId } of this._plannedRegistryWrites) {
         this._registry.ids[key] = taskId;
       }
-
-      const completedWrites = [];
-      const rollback = (reason) => {
-        for (const done of completedWrites.reverse()) {
-          try {
-            fs.writeFileSync(done.taskMdPath, done.originalContent);
-            fs.utimesSync(done.taskMdPath, done.originalAtime, done.originalMtime);
-          } catch {
-            /* best-effort */
-          }
-        }
-        this._registry.ids = this._registrySnapshot;
-        const tail =
-          completedWrites.length > 0
-            ? `; rolled back ${completedWrites.length} prior task.md write(s)`
-            : "";
-        throw new Error(`${reason}${tail}`);
-      };
-
-      // B2: write task.md per plan
-      for (const write of this._plannedTaskMdWrites) {
-        try {
-          writeTaskMdShortId(write.taskMdPath, write.shortId);
-          completedWrites.push(write);
-        } catch (e) {
-          rollback(`Failed to write short_id to ${write.taskMdPath}: ${e.message}`);
-        }
-      }
-
-      // B3: atomic registry persistence
       try {
         writeRegistryAtomic(this._registry, registryPath);
       } catch (e) {
-        rollback(`Failed to persist registry to ${registryPath}: ${e.message}`);
+        this._registry.ids = this._registrySnapshot;
+        throw new Error(`Failed to persist registry to ${registryPath}: ${e.message}`);
       }
     }
   };
@@ -449,27 +313,10 @@ function verifyRegistry(registry, activeDir) {
       .filter((d) => fs.existsSync(path.join(activeDir, d, "task.md")))
   );
   const registryTaskIds = new Set(Object.values(registry.ids));
-  const taskmdShortIds = new Map();
-  for (const taskId of activeTaskIds) {
-    const taskMdPath = path.join(activeDir, taskId, "task.md");
-    const content = fs.readFileSync(taskMdPath, "utf8");
-    const m = content.match(/^short_id:\s*(#\d+)\s*$/m);
-    taskmdShortIds.set(taskId, m ? m[1] : null);
-  }
   const missing_in_registry = [];
   for (const taskId of activeTaskIds) {
     if (!registryTaskIds.has(taskId)) {
-      missing_in_registry.push({ taskId, declared: taskmdShortIds.get(taskId) });
-    }
-  }
-  const missing_in_taskmd = [];
-  for (const [key, taskId] of Object.entries(registry.ids)) {
-    if (!activeTaskIds.has(taskId)) continue;
-    const declared = taskmdShortIds.get(taskId);
-    if (declared === null) {
-      missing_in_taskmd.push({ taskId, expected: `#${key}` });
-    } else if (declared !== `#${key}`) {
-      missing_in_taskmd.push({ taskId, expected: `#${key}`, declared });
+      missing_in_registry.push({ taskId });
     }
   }
   const orphans_in_registry = [];
@@ -491,7 +338,6 @@ function verifyRegistry(registry, activeDir) {
   }
   return {
     missing_in_registry,
-    missing_in_taskmd,
     orphans_in_registry,
     duplicate_registry_keys
   };
@@ -548,8 +394,8 @@ function cmdRelease(taskId, activeDir, registryPath, shortIdLength) {
 }
 
 function cmdResolve(shortIdArg, activeDir, registryPath, shortIdLength) {
-  // Strict width match + reserved key check; on invalid arg, parseShortIdArg writes full
-  // stderr (including "expected #NN (N-digit zero-padded; e.g. '#01')") and exits 1.
+  // Accepts bare digits ('11') or '#'-prefixed form ('#11', '#11', '#005'); normalized by
+  // numeric value with capacity check (n > 10^L-1) and reserved-zero rejection.
   const key = parseShortIdArg(shortIdArg, shortIdLength);
   return withRegistryLock(activeDir, () => {
     const registry = readRegistry(registryPath);
@@ -558,8 +404,7 @@ function cmdResolve(shortIdArg, activeDir, registryPath, shortIdLength) {
     if (!taskId) {
       const hasPendingMutations =
         tx._plannedRegistryWrites.length > 0 ||
-        tx._pendingRegistryDeletes.length > 0 ||
-        tx._plannedTaskMdWrites.length > 0;
+        tx._pendingRegistryDeletes.length > 0;
       if (hasPendingMutations) {
         try {
           tx.commit(registryPath);
@@ -604,7 +449,6 @@ function cmdList(activeDir, registryPath, verify) {
   const diff = verifyRegistry(registry, activeDir);
   const hasIssues =
     diff.missing_in_registry.length > 0 ||
-    diff.missing_in_taskmd.length > 0 ||
     diff.orphans_in_registry.length > 0 ||
     diff.duplicate_registry_keys.length > 0;
   if (hasIssues) {
@@ -699,7 +543,6 @@ export {
   readRegistry,
   writeRegistryAtomic,
   withRegistryLock,
-  writeTaskMdShortId,
   padShortId,
   parseShortIdArg,
   allocateMinFreeInt,

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

@@ -29,7 +29,7 @@ Before the state check is complete, do not make external-state assertions such a
 
 ## 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.
+> If `{task-id}` matches `^[#]?[0-9]+$` (bare numeric or `#`-prefixed), 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.
 
 ## Steps
 
@@ -65,6 +65,8 @@ If `task.md` contains these source fields, also read the corresponding source in
 - `codescan_alert_number` - Code Scanning alert
 - `security_alert_number` - Dependabot alert
 
+**Round ≥ 2: respond to the prior review (only when a review artifact exists)**: if the task directory contains `review-analysis.md` / `review-analysis-r{N}.md`, read the highest-round review report; add a `## Response to Prior Review` section to this round's analysis artifact, and for each finding verify it via Read/Grep before acting (holds → accept and fix; judged hallucinated/unfounded → rebut with counter-evidence rather than defaulting to compliance); record any open disagreement under `## Open Questions`. Round 1 has no review, so skip this section.
+
 ### 4. Perform Requirements Analysis
 
 Before analysis begins: if `start_date` in the frontmatter is empty, write today's date immediately (command: `date +%F`, format `YYYY-MM-DD`); keep any existing value. Before writing, read `.agents/rules/version-stamp.md` and refresh `updated_at` / `agent_infra_version` at the same time.
@@ -154,15 +156,11 @@ Update `.agents/workspace/active/{task-id}/task.md`:
 - Mark requirement-analysis as complete in workflow progress and include the actual round when the task template supports it
 - Before appending the workflow Activity Log entry, re-estimate `priority` based on the analysis findings (business impact, risks, dependencies, blockers). If the re-estimated value differs from the current value in `task.md`:
   - Overwrite the `priority` field in frontmatter with the new value
-  - Prepend an Activity Log entry recording the transition (placed before the `Requirement Analysis (Round N)` entry):
-    ```
-    - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Analysis Re-estimate** by {agent} — priority {old} → {new} (rationale: {short basis grounded in this analysis})
-    ```
-  Both entries may share the same timestamp; ordering is conveyed by list position only.
-  If the re-estimated value matches the current value, skip the Re-estimate entry. The Flow A sync that follows reads the possibly updated frontmatter and propagates the new value to the Issue automatically.
+  - Append a `## Priority Re-estimate` section to this round's analysis artifact `{analysis-artifact}`, recording: `priority {old} → {new} (rationale: {short basis grounded in this analysis})`
+  If the re-estimated value matches the current value, skip it: do not write the `## Priority Re-estimate` section. The Flow A sync that follows reads the possibly updated frontmatter and propagates the new value to the Issue automatically.
 - **Append** to `## Activity Log` (do NOT overwrite previous entries):
   ```
-  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Requirement Analysis (Round {N})** by {agent} — Analysis completed → {analysis-artifact}
+  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Analyze Task (Round {N})** by {agent} — Analysis completed → {analysis-artifact}
   ```
 
 If task.md contains a valid `issue_number`, perform these sync actions (skip and continue on any failure):
@@ -191,7 +189,7 @@ Keep the gate output in your reply as fresh evidence. Do not claim completion wi
 
 > 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).
+> **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). Before rendering the "Next steps" commands, read `.agents/rules/next-step-output.md` and use its short-id snippet to render `{task-ref}` in the commands as the short id `#NN` (falling back to the full TASK-id when unallocated or released).
 
 Output format:
 ```
@@ -206,9 +204,9 @@ Output file:
 - Analysis report: .agents/workspace/active/{task-id}/{analysis-artifact}
 
 Next step - review the analysis:
-  - Claude Code / OpenCode: /review-analysis {task-id}
-  - Gemini CLI: /{{project}}:review-analysis {task-id}
-  - Codex CLI: $review-analysis {task-id}
+  - Claude Code / OpenCode: /review-analysis {task-ref}
+  - Gemini CLI: /{{project}}:review-analysis {task-ref}
+  - Codex CLI: $review-analysis {task-ref}
 ```
 
 ## Completion Checklist

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

@@ -29,7 +29,7 @@ tail .agents/workspace/active/{task-id}/task.md
 
 ## 任务入参短号别名
 
-> 如果 `{task-id}` 入参以 `#` 开头，先读取 `.agents/rules/task-short-id.md` 的「SKILL 入参解析」段执行解析；后续命令视 `{task-id}` 为解析后的全长 `TASK-YYYYMMDD-HHMMSS` 形式。
+> 如果 `{task-id}` 入参匹配 `^[#]?[0-9]+$`（裸数字或带 `#` 前缀），先读取 `.agents/rules/task-short-id.md` 的「SKILL 入参解析」段执行解析；后续命令视 `{task-id}` 为解析后的全长 `TASK-YYYYMMDD-HHMMSS` 形式。
 
 ## 执行步骤
 ### 1. 验证前置条件
@@ -64,6 +64,8 @@ tail .agents/workspace/active/{task-id}/task.md
 - `codescan_alert_number` - Code Scanning 告警
 - `security_alert_number` - Dependabot 告警
 
+**Round ≥ 2：响应上一轮审查（仅当存在审查产物时）**：若任务目录存在 `review-analysis.md` / `review-analysis-r{N}.md`，读取最高轮次的审查报告；在本轮分析产物中新增 `## 对上一轮审查的响应` 段，对每条发现先 Read/Grep 核实再处置（成立 → 接受并修正；判定为幻觉/不成立 → 附反证反驳，不默认顺从），未决分歧写入 `## 未决问题`。Round 1 无审查，跳过本段。
+
 ### 4. 执行需求分析
 
 开始分析前：若 frontmatter 的 `start_date` 为空，立即写入当日日期（命令 `date +%F`，格式 `YYYY-MM-DD`）；已有值则保留。写入前先读取 `.agents/rules/version-stamp.md`，并同步刷新 `updated_at` / `agent_infra_version`。
@@ -153,15 +155,11 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 - 在工作流进度中标记 requirement-analysis 为已完成，并注明实际轮次（如果任务模板支持）
 - 在追加工作流 Activity Log 条目之前，基于分析结果（业务影响、风险、依赖、阻塞条件）重估 `priority`。若重估值与 `task.md` 当前值不一致：
   - 用新值覆盖 frontmatter 的 `priority` 字段
-  - 在 `Requirement Analysis (Round N)` 条目之前追加一条转移记录：
-    ```
-    - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Analysis Re-estimate** by {agent} — priority {old} → {new} (rationale: {基于本轮分析的简短依据})
-    ```
-  两条条目可共用同一时间戳，顺序仅通过列表位置表达。
-  若重估值与当前值一致，跳过 Re-estimate 条目。后续 Flow A 同步会读取可能更新过的 frontmatter，并自动把新值同步到 Issue。
+  - 在本轮分析产物 `{analysis-artifact}` 中追加 `## 优先级重估` 段，记录一条：`priority {old} → {new} (rationale: {基于本轮分析的简短依据})`
+  若重估值与当前值一致，跳过：不写入 `## 优先级重估` 段。后续 Flow A 同步会读取可能更新过的 frontmatter，并自动把新值同步到 Issue。
 - **追加**到 `## Activity Log`（不要覆盖之前的记录）：
   ```
-  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Requirement Analysis (Round {N})** by {agent} — Analysis completed → {analysis-artifact}
+  - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Analyze Task (Round {N})** by {agent} — Analysis completed → {analysis-artifact}
   ```
 
 如果 task.md 中存在有效的 `issue_number`，执行以下同步操作（任一失败则跳过并继续）：
@@ -190,7 +188,7 @@ node .agents/scripts/validate-artifact.js gate analyze-task .agents/workspace/ac
 
 > 仅在校验通过后执行本步骤。
 
-> **重要**：以下「下一步」中列出的所有 TUI 命令格式必须完整输出，不要只展示当前 AI 代理对应的格式。如果 `.agents/.airc.json` 中配置了自定义 TUI（`customTUIs`），读取每个工具的 `name` 和 `invoke`，按同样格式补充对应命令行（`${skillName}` 替换为技能名，`${projectName}` 替换为项目名）。
+> **重要**：以下「下一步」中列出的所有 TUI 命令格式必须完整输出，不要只展示当前 AI 代理对应的格式。如果 `.agents/.airc.json` 中配置了自定义 TUI（`customTUIs`），读取每个工具的 `name` 和 `invoke`，按同样格式补充对应命令行（`${skillName}` 替换为技能名，`${projectName}` 替换为项目名）。 渲染「下一步」命令前，先读取 `.agents/rules/next-step-output.md`，按其取短号片段把命令中的 `{task-ref}` 渲染为短号 `#NN`（未分配/已释放时回退完整 TASK-id）。
 
 输出格式：
 ```
@@ -205,9 +203,9 @@ node .agents/scripts/validate-artifact.js gate analyze-task .agents/workspace/ac
 - 分析报告：.agents/workspace/active/{task-id}/{analysis-artifact}
 
 下一步 - 审查需求分析：
-  - Claude Code / OpenCode：/review-analysis {task-id}
-  - Gemini CLI：/agent-infra:review-analysis {task-id}
-  - Codex CLI：$review-analysis {task-id}
+  - Claude Code / OpenCode：/review-analysis {task-ref}
+  - Gemini CLI：/agent-infra:review-analysis {task-ref}
+  - Codex CLI：$review-analysis {task-ref}
 ```
 
 ## 完成检查清单

package/templates/.agents/skills/analyze-task/config/verify.en.json

@@ -32,7 +32,7 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Requirement Analysis \\(Round \\d+\\)",
+      "expected_action_pattern": "(Analyze Task|Requirement Analysis) \\(Round \\d+\\)",
       "freshness_minutes": 30
     },
     "platform-sync": {