@fitlab-ai/agent-infra 0.11.15 → 0.12.1

package/templates/.agents/skills/review-pr/config/verify.zh-CN.json

@@ -23,7 +23,6 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Review PR \\(Round \\d+\\)"
     },
     "platform-sync": {
       "when": "platform_issue_identity_exists"

package/templates/.agents/skills/review-pr/reference/output-guidance.en.md

@@ -8,7 +8,7 @@ Read this file and `.agents/rules/next-step-output.md` before presenting the fin
 |------|---------|---------|
 | A Local review complete | the local review round closed and verification passed; formal publication succeeded or has a durable pending record | conclusion, mode, reviewed head SHA, actual publication status, Review URL or recovery action, receipt, next step |
 | B Blocked, requires linking | `resolve-host` returned none or ambiguous | linking guidance (create/link an Issue and task); do not auto-create an Issue; or explicitly choose the one-shot review |
-| C One-shot review | the user explicitly chose a "one-shot review" | non-recoverable notice, artifact directory `.agents/workspace/reviews/{pr-number}/`, Review URL or publication failure |
+| C One-shot review | the user explicitly chose a "one-shot review" | non-recoverable notice, artifact directory `<task-workspace>/reviews/{pr-number}/`, Review URL or publication failure |
 
 ## Presentation Requirements
 

package/templates/.agents/skills/review-pr/reference/output-guidance.zh-CN.md

@@ -8,7 +8,7 @@
 |------|----------|----------|
 | A 本地审查完成 | 本地审查轮次闭合且校验通过；正式 Review 已发布或有持久化待恢复记录 | 结论、模式、被审 head SHA、实际发布状态、Review URL 或恢复动作、receipt、下一步 |
 | B 阻塞要求关联 | `resolve-host` 返回 none 或 ambiguous | 关联指引（创建/关联 Issue 与 task），不自动创建 Issue；或显式选择一次性检视 |
-| C 一次性检视 | 用户显式选择「仅一次性检视」 | 不可恢复提示、产物目录 `.agents/workspace/reviews/{pr-number}/`、Review URL 或发布失败 |
+| C 一次性检视 | 用户显式选择「仅一次性检视」 | 不可恢复提示、产物目录 `<task-workspace>/reviews/{pr-number}/`、Review URL 或发布失败 |
 
 ## 呈现要求
 

package/templates/.agents/skills/run-manual-validation/config/verify.en.json

@@ -34,7 +34,6 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Run Manual Validation \\(Round \\d+\\)"
     },
     "review-ledger": {
       "stage_scope": [

package/templates/.agents/skills/run-manual-validation/config/verify.zh-CN.json

@@ -34,7 +34,6 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Run Manual Validation \\(Round \\d+\\)"
     },
     "review-ledger": {
       "stage_scope": [

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

@@ -19,7 +19,7 @@ The orchestrator delegates only and never executes a stage skill itself. First r
 4. Run `task-orchestration {task-id} begin-or-resume --client {client}` with the complete explicit policy. With no explicit policy, core reads that client's configured policy; existing runs use persisted policy. Disk state outside the complete current structure fails closed without rewriting; finish or clear active runs before upgrading. Stop on paused/completed results.
 5. Run `route`. On `completed`, run `agent-infra-internal task-verify {task-id} run-task.completed --format text`, present its summary per `.agents/rules/validation-output.md` while retaining necessary diagnostics, and stop. Only a `running` result with non-null `next` supplies action, role, round, artifact, requested model, and requested effort.
 6. Call `prepare --client {client} --requested-model {requestedModel} --requested-reasoning-effort {requestedReasoningEffort}` with route's exact policy. The client adapter runs host preflight. Report actual task, policy, or host failures.
-7. After prepare, forward the optional `adapterContext` unchanged to `agent-infra-internal agent-client launch-carrier --client {client} --adapter-context {adapterContext} --stage {stage} --round {round} --role {role} --format json`. The shared skill must not parse, rewrite, or validate this opaque value. The controlled entry point calls the current Agent Client adapter's `createLaunchCarrier` and returns a carrier for native spawn. Stop dispatch with the structured error if carrier support is unavailable or conversion fails. Then run `task-orchestration <task-ref> dispatch` with route's exact model/effort, passing the short task ref, skill, `--orchestrated`, stage/round/artifact/role, and the returned carrier unchanged to native spawn. The child calls `await-activation --stage ... --round ... --artifact ... --role ...` to associate its actual identity before executing. Code-task creates the local checkpoint; do not delegate a separate commit stage or push. Retain existing write locks without introducing a new lock protocol around native spawn.
+7. After prepare, forward the optional `adapterContext` unchanged to `agent-infra-internal agent-client launch-carrier --client {client} --adapter-context {adapterContext} --stage {stage} --round {round} --role {role} --format json`. The shared skill must not parse, rewrite, or validate this opaque value. The controlled entry point calls the current Agent Client adapter's `createLaunchCarrier` and returns a carrier for native spawn. Stop dispatch with the structured error if carrier support is unavailable or conversion fails. Then run `task-orchestration <task-ref> dispatch` with route's exact model/effort, passing the short task ref, skill, `--orchestrated`, stage/round/artifact/role, and the returned carrier unchanged to native spawn. The child calls `await-activation --stage ... --round ... --artifact ... --role ...` to associate its actual identity before executing. Code-task creates the local checkpoint; do not delegate a separate commit stage or push. Execute task stages sequentially; state updates retain atomic writes and identity/state validation.
 8. Record actual start and terminal results through the current host's native lifecycle events and result interfaces. A timed-out wait does not imply success. Pause on actual identity, transport, or terminal failures. After the stage and child finish, call `advance`; repeat step 3 only while running.
 9. Create a fresh child each round and never reuse a reviewer. Record actual model/effort and host fallback reasons. Validate current identity, artifacts, ledger, and execution results. User rulings override derived historical plan requirements. Do not introduce child discovery, orphan recovery, or a dedicated recovery protocol.
 10. On pause or completion, run the matching typed verification and report the structured endpoint.

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

@@ -19,7 +19,7 @@ description: >
 4. 调用 `agent-infra-internal task-orchestration {task-id} begin-or-resume --client {client}` 并转发完整显式策略。完全没有显式策略时由核心读取当前 client 的 `agentClients[].orchestration`；existing run 使用持久化策略。磁盘状态不符合当前完整结构时核心失败关闭且不改写；升级前必须完成或清空 active run。仅当核心返回 `ORCHESTRATION_MODEL_POLICY_REQUIRED` 时，先用 `agent-client model-selection` 展示 complete/partial/interactive-only 来源，再一次收集完整策略；未回答则不创建 run。若为 paused/completed，按结构化结果停止。
 5. 调用 `route` 并读取结构化结果。若返回 `completed`，立即运行 `agent-infra-internal task-verify {task-id} run-task.completed --format text` 并停止；按 `.agents/rules/validation-output.md` 展示摘要并保留必要诊断。仅当返回 `running` 且 `next` 非空时读取唯一 action、role、round、artifact、`requestedModel` 和 `requestedReasoningEffort`，不得自行推断。
 6. 调用 `prepare --client {client} --requested-model {requestedModel} --requested-reasoning-effort {requestedReasoningEffort}`，使用 route 返回的精确策略。客户端适配器执行宿主 preflight；任务身份、策略或宿主检查失败时记录实际诊断。
-7. prepare 成功后，原样转发返回的可选 `adapterContext`，调用 `agent-infra-internal agent-client launch-carrier --client {client} --adapter-context {adapterContext} --stage {stage} --round {round} --role {role} --format json`。共享技能不解析、重写或验证该不透明值；受控入口调用当前 Agent Client adapter 的 `createLaunchCarrier`，并返回可直接交给 native spawn 的 carrier。缺少 carrier 能力或转换失败时按结构化错误停止派发。随后执行 `task-orchestration <task-ref> dispatch`，显式指定 route 返回的 model/effort；传递短任务引用、skill 名、`--orchestrated` 与 stage/round/artifact/role，并把返回的 carrier 原样交给 native spawn。child 调用 `await-activation --stage ... --round ... --artifact ... --role ...`，确认当前阶段与实际 child 关联后执行。代码阶段通过 code-task 创建本地 checkpoint；禁止单独委派 commit 阶段或推送。保留已有写锁，不把实际 spawn 纳入新建锁协议。
+7. prepare 成功后，原样转发返回的可选 `adapterContext`，调用 `agent-infra-internal agent-client launch-carrier --client {client} --adapter-context {adapterContext} --stage {stage} --round {round} --role {role} --format json`。共享技能不解析、重写或验证该不透明值；受控入口调用当前 Agent Client adapter 的 `createLaunchCarrier`，并返回可直接交给 native spawn 的 carrier。缺少 carrier 能力或转换失败时按结构化错误停止派发。随后执行 `task-orchestration <task-ref> dispatch`，显式指定 route 返回的 model/effort；传递短任务引用、skill 名、`--orchestrated` 与 stage/round/artifact/role，并把返回的 carrier 原样交给 native spawn。child 调用 `await-activation --stage ... --round ... --artifact ... --role ...`，确认当前阶段与实际 child 关联后执行。代码阶段通过 code-task 创建本地 checkpoint；禁止单独委派 commit 阶段或推送。任务阶段按序执行，状态更新保留原子写入与身份、状态校验。
 8. 通过当前宿主的原生生命周期事件和结果接口记录实际启动及终态。timed-out wait 不推断成功；身份、传输或异常终态失败如实暂停。阶段结果和 child 完成后调用 `advance`；只有 `running` 才重复步骤 3。
 9. 每轮创建新 child；禁止 follow-up 复用 reviewer。如实记录 actual model/effort 及宿主降级理由。检查当前身份、产物、账本与实际执行结果；用户裁决优先于历史方案派生要求。不得新增 child discovery、孤立 child 恢复或专用恢复协议。
 10. 完成或暂停后运行对应 typed verification，并把结构化 run 摘要、暂停原因、commit 终点或 clean completion evidence 告知用户。

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

@@ -120,6 +120,3 @@ Populate `{next-step-commands}` for this scenario by running `agent-infra-intern
 Next step - commit changes:
 {next-step-commands}
 ```
-
-
-For an in-scope, diagnosable failure, inspect the error evidence, identify the cause, fix it, and retry with the same verifier; do not stop or ask merely because an ordinary attempt failed. Preserve a blocked state for user data/template conflicts, design choices beyond approved scope, required human validation/authorization, or unsafe recovery, and continue independent work.

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

@@ -118,6 +118,3 @@ description: >
 下一步 - 提交代码：
 {next-step-commands}
 ```
-
-
-遇到任务范围内且可诊断的失败，先读取错误证据、定位根因、修复并按同一验证器重试；不要仅因一次普通失败就停止或提问。若涉及用户数据/模板冲突、超出批准范围的设计选择、必要人工验证/授权或无法安全恢复，则保留阻塞事实并继续独立工作。

package/templates/.agents/skills/test-integration/SKILL.en.md

@@ -67,6 +67,3 @@ Next step - commit changes:
 2. **Environment**: Integration tests may require external services (databases, APIs, etc.)
 3. **Timeouts**: Integration tests typically take longer; be patient
 4. **Cleanup**: Ensure test environment is cleaned up after tests complete
-
-
-For an in-scope, diagnosable failure, inspect the error evidence, identify the cause, fix it, and retry with the same verifier; do not stop or ask merely because an ordinary attempt failed. Preserve a blocked state for user data/template conflicts, design choices beyond approved scope, required human validation/authorization, or unsafe recovery, and continue independent work.

package/templates/.agents/skills/test-integration/SKILL.zh-CN.md

@@ -67,6 +67,3 @@ description: >
 2. **环境**：集成测试可能需要外部服务（数据库、API 等）
 3. **超时**：集成测试通常耗时较长；请耐心等待
 4. **清理**：确保测试完成后清理测试环境
-
-
-遇到任务范围内且可诊断的失败，先读取错误证据、定位根因、修复并按同一验证器重试；不要仅因一次普通失败就停止或提问。若涉及用户数据/模板冲突、超出批准范围的设计选择、必要人工验证/授权或无法安全恢复，则保留阻塞事实并继续独立工作。

package/templates/.agents/skills/update-agent-infra/scripts/sync-templates.js

@@ -994,19 +994,26 @@ function entryVariantRels(entry, allSet, platform) {
   return rels;
 }
 
-function ensureRuntimeWorkspace(projectRoot) {
+function ensureRuntimeWorkspace(projectRoot, project) {
+  if (typeof project !== 'string' || !project || project === '.' || project === '..' || /[\\/\u0000-\u001f\u007f]/u.test(project)) {
+    throw new Error('Runtime task workspace requires a valid project key in .agents/.airc.json');
+  }
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  if (!path.isAbsolute(home)) throw new Error('Runtime task workspace requires an absolute HOME');
+  const workspaceRoot = path.join(home, '.agent-infra', 'task-workspaces', project);
   const directories = [
-    path.join(projectRoot, '.agents'),
-    path.join(projectRoot, '.agents', 'workspace'),
+    path.join(home, '.agent-infra'),
+    path.join(home, '.agent-infra', 'task-workspaces'),
+    workspaceRoot,
     ...['active', 'blocked', 'completed', 'archive'].map((state) =>
-      path.join(projectRoot, '.agents', 'workspace', state)
+      path.join(workspaceRoot, state)
     )
   ];
   for (const directory of directories) {
     if (fs.existsSync(directory)) {
       const stat = fs.lstatSync(directory);
       if (!stat.isDirectory() || stat.isSymbolicLink()) {
-        throw new Error(`Runtime workspace path must be a real directory: ${directory}`);
+        throw new Error(`Runtime task workspace path must be a real directory: ${directory}`);
       }
       continue;
     }
@@ -1024,7 +1031,7 @@ function syncTemplates(projectRoot, templateRootOverride) {
 
   const originalConfigText = fs.readFileSync(cfgPath, 'utf8');
   const cfg = JSON.parse(originalConfigText);
-  ensureRuntimeWorkspace(projectRoot);
+  ensureRuntimeWorkspace(projectRoot, cfg.project);
   const configPathRel = norm(path.relative(projectRoot, cfgPath));
   let templateRoot = templateRootOverride;
   if (!templateRoot) {

package/templates/.agents/skills/upgrade-dependency/SKILL.en.md

@@ -85,6 +85,3 @@ Next step - commit changes:
 - Package not found: Prompt "Package {name} not found in dependency files"
 - Build failure: Output errors and suggest checking for breaking changes
 - Test failure: Diagnose and fix recoverable in-scope issues, then rerun the same verifier; report migration-guide risks when relevant
-
-
-For an in-scope, diagnosable failure, inspect the error evidence, identify the cause, fix it, and retry with the same verifier; do not stop or ask merely because an ordinary attempt failed. Preserve a blocked state for user data/template conflicts, design choices beyond approved scope, required human validation/authorization, or unsafe recovery, and continue independent work.

package/templates/.agents/skills/upgrade-dependency/SKILL.zh-CN.md

@@ -85,6 +85,3 @@ description: >
 - 包未找到：提示 "Package {name} not found in dependency files"
 - 构建失败：输出错误并建议检查破坏性变更
 - 测试失败：先诊断并修复任务范围内可恢复的问题，再按同一验证器复测；必要时记录迁移指南相关风险
-
-
-遇到任务范围内且可诊断的失败，先读取错误证据、定位根因、修复并按同一验证器重试；不要仅因一次普通失败就停止或提问。若涉及用户数据/模板冲突、超出批准范围的设计选择、必要人工验证/授权或无法安全恢复，则保留阻塞事实并继续独立工作。

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

@@ -40,7 +40,7 @@ After prerequisites pass and before this round's first artifact action, append a
 Resolve the target PR number `{pr#}` and an optional `{task-id}` via these deterministic branches:
 
 - Scenario A (argument omitted): reverse-lookup the active task from the current branch, then read its verified `pr_delivery_fact.identity.number`.
-- Scenario B (omitted task ref or `--task/-t`, **task-anchored primary path**): resolve the full `{task-id}` via "Task Context Resolution" and read `.agents/workspace/active/{task-id}/task.md` for verified `pr_delivery_fact.identity.number` as `{pr#}`; if the fact is unbound, follow "Error Handling" to prompt running `create-pr` first, then stop.
+- Scenario B (omitted task ref or `--task/-t`, **task-anchored primary path**): resolve the full `{task-id}` via "Task Context Resolution" and read `<task-workspace>/active/{task-id}/task.md` for verified `pr_delivery_fact.identity.number` as `{pr#}`; if the fact is unbound, follow "Error Handling" to prompt running `create-pr` first, then stop.
 - Scenario C (`--pr <number>` or a PR URL): use that PR number directly as `{pr#}`; then determine `{task-id}` via "Reverse-lookup task".
 - Reverse-lookup task (scenarios A / C): use task context/query capabilities to find the unique active task bound to `{pr#}`. If none exists, stop and request binding first; the typed checks intent does not create a second taskless state machine.
 
@@ -53,7 +53,7 @@ Initialize `repairCommits=[]` and `rebaseAttempts=0`. Before overwriting the cur
 ```bash
 node --experimental-strip-types --input-type=module -e '
 import { readPrChangeReport } from "./lib/platform/pr-change-report.ts";
-const report = readPrChangeReport(`.agents/workspace/active/${process.argv[1]}/pr-change-report.json`);
+const report = readPrChangeReport(`<task-workspace>/active/${process.argv[1]}/pr-change-report.json`);
 const previous = report.ok
   ? { repository: report.value.identity.repository, resource: report.value.identity.resource, head: report.value.identity.head.sha }
   : { status: "unavailable" };
@@ -61,7 +61,7 @@ process.stdout.write(`${JSON.stringify(previous)}\n`);
 ' {task-id}
 ```
 
-Then run `platform-pr summary-context` and compare the retained repository/resource identity with the authoritative snapshot; discard a mismatch and mark the increment unconfirmed. Rebuild the task-bound `pr-change-report.json` for the authoritative PR head using the shared PR change-report contract, and refresh the single summary with a body containing one `<!-- canonical-pr-change-report -->` placeholder via `summary-sync --change-report-file ... --result no_op --strict`. Complete-PR statistics keep the current base/head/merge-base/patch and existing totals. Only when the prior report is valid, the PR identity matches, and the heads differ, describe the separate head-to-head tree diff using `git diff --find-renames --numstat {previous-head} {current-head}`, `--name-status`, and `--summary`. Do not substitute a merge-base diff for this range or add increment totals to the full PR. If no valid prior head exists, state that it is unconfirmed; do not infer from complete-PR statistics or fill in zeroes. Matching heads mean there was no new head transition.
+Then run `platform-pr summary-context` and compare the retained repository/resource identity with the authoritative snapshot; discard a mismatch and mark the increment unconfirmed. Rebuild the task-bound `pr-change-report.json` for the authoritative PR head using the shared PR change-report contract, and refresh the single summary with structured summary JSON via `summary-sync --change-report-file ... --result no_op --strict`. Preserve the actual test, review, and manual validation states; do not depend on later events or final verification. Complete-PR statistics keep the current base/head/merge-base/patch and existing totals. Only when the prior report is valid, the PR identity matches, and the heads differ, describe the separate head-to-head tree diff using `git diff --find-renames --numstat {previous-head} {current-head}`, `--name-status`, and `--summary`. Do not substitute a merge-base diff for this range or add increment totals to the full PR. If no valid prior head exists, state that it is unconfirmed; do not infer from complete-PR statistics or fill in zeroes. Matching heads mean there was no new head transition.
 
 `--strict` preserves report or summary refresh failures as `failed/blocked` instead of treating warnings as success. A report or summary refresh failure must not enter the ready/complete exit; use step 4. After a successful refresh, consume `nextAction` from the structured `summary-sync` result: `review-code` exits readiness/self-heal and follows the code-review branch in step 7; only `watch-pr` continues to `agent-infra-internal platform-checks watch {task-id} --interval-seconds 30 --deadline-seconds 1800`. Missing or invalid `nextAction` follows the refresh-failure exit; do not infer `watch-pr`. Route readiness only by `readiness.state`: `ready` to step 7, `conflicting|checks-failed` to step 3, and `pending|timed-out|cancelled` to step 4.
 
@@ -85,7 +85,7 @@ Get the current time:
 date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
-Update `.agents/workspace/active/{task-id}/task.md`:
+Update `<task-workspace>/active/{task-id}/task.md`:
 - `assigned_to`: {current agent}
 - `updated_at`: {current time}
 - `agent_infra_version`: per `.agents/rules/version-stamp.md`

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

@@ -40,7 +40,7 @@ description: >
 按以下确定性分支解析出目标 PR 号 `{pr#}` 与可选 `{task-id}`：
 
 - 场景 A（省略入参）：从当前分支反查 active task；定位后读取其 verified `pr_delivery_fact.identity.number`。
-- 场景 B（省略 task ref 或 `--task/-t`，**任务锚定主路径**）：按「任务上下文解析」取得完整 `{task-id}`。读 `.agents/workspace/active/{task-id}/task.md` 取 verified `pr_delivery_fact.identity.number` 作为 `{pr#}`；fact 未绑定时按「错误处理」提示先 `create-pr`，停止。
+- 场景 B（省略 task ref 或 `--task/-t`，**任务锚定主路径**）：按「任务上下文解析」取得完整 `{task-id}`。读 `<task-workspace>/active/{task-id}/task.md` 取 verified `pr_delivery_fact.identity.number` 作为 `{pr#}`；fact 未绑定时按「错误处理」提示先 `create-pr`，停止。
 - 场景 C（`--pr <number>` 或 PR URL）：直接取该 PR 号为 `{pr#}`；随后按「反查任务」确定 `{task-id}`。
 - 反查任务（场景 A / C）：通过任务上下文/任务查询取得与 `{pr#}` 唯一绑定的 active task。未命中时停止并提示先绑定 PR；typed checks intent 不建立第二套无任务状态机。
 
@@ -53,7 +53,7 @@ description: >
 ```bash
 node --experimental-strip-types --input-type=module -e '
 import { readPrChangeReport } from "./lib/platform/pr-change-report.ts";
-const report = readPrChangeReport(`.agents/workspace/active/${process.argv[1]}/pr-change-report.json`);
+const report = readPrChangeReport(`<task-workspace>/active/${process.argv[1]}/pr-change-report.json`);
 const previous = report.ok
   ? { repository: report.value.identity.repository, resource: report.value.identity.resource, head: report.value.identity.head.sha }
   : { status: "unavailable" };
@@ -61,7 +61,7 @@ process.stdout.write(`${JSON.stringify(previous)}\n`);
 ' {task-id}
 ```
 
-随后调用 `platform-pr summary-context`，比较暂存的 repository/resource identity 与当前权威 snapshot；不匹配时丢弃旧 head 并标记增量未确认。按共享 PR change-report contract 用当前权威 PR head 重建任务绑定的 `pr-change-report.json`，再用含唯一 `<!-- canonical-pr-change-report -->` 占位符的正文调用 `summary-sync --change-report-file ... --result no_op --strict` 刷新同一条摘要。完整 PR 仍使用当前 base/head/merge-base/patch 与现有 totals。只有在上一报告有效、PR identity 相同且两个 head 不同的情况下，才用 `git diff --find-renames --numstat {previous-head} {current-head}`、`--name-status`、`--summary` 描述独立的 head→head 树差异；不使用 merge-base 替代该范围，不把增量 totals 加入完整 PR。无有效上一 head 时写明未确认，不从完整 PR 推算或填零；head 相同只说明没有新的 head 转换。
+随后调用 `platform-pr summary-context`，比较暂存的 repository/resource identity 与当前权威 snapshot；不匹配时丢弃旧 head 并标记增量未确认。按共享 PR change-report contract 用当前权威 PR head 重建任务绑定的 `pr-change-report.json`，用结构化摘要 JSON 调用 `summary-sync --change-report-file ... --result no_op --strict` 刷新同一条摘要；保留测试、Review 和人工校验的真实状态，不能依赖后续事件或最终验证。完整 PR 仍使用当前 base/head/merge-base/patch 与现有 totals。只有在上一报告有效、PR identity 相同且两个 head 不同的情况下，才用 `git diff --find-renames --numstat {previous-head} {current-head}`、`--name-status`、`--summary` 描述独立的 head→head 树差异；不使用 merge-base 替代该范围，不把增量 totals 加入完整 PR。无有效上一 head 时写明未确认，不从完整 PR 推算或填零；head 相同只说明没有新的 head 转换。
 
 `--strict` 将报告或摘要刷新失败保留为 `failed/blocked`，不得把 warning 当作成功；刷新失败时不得进入 ready/complete 出口，按步骤 4 记录阻塞。刷新成功后，消费 `summary-sync` 结构化结果的 `nextAction`：`review-code` 立即结束 readiness/self-heal 路径，按步骤 7 的代码审查分支退出；`watch-pr` 才继续调用 `agent-infra-internal platform-checks watch {task-id} --interval-seconds 30 --deadline-seconds 1800`。缺失或 invalid `nextAction` 按刷新失败处理，不推断为 `watch-pr`。readiness 只按结构化 `readiness.state` 分流：`ready` 进入步骤 7，`conflicting` 或 `checks-failed` 进入步骤 3，`pending|timed-out|cancelled` 进入步骤 4。
 
@@ -85,7 +85,7 @@ process.stdout.write(`${JSON.stringify(previous)}\n`);
 date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
-更新 `.agents/workspace/active/{task-id}/task.md`：
+更新 `<task-workspace>/active/{task-id}/task.md`：
 - `assigned_to`：{当前代理}
 - `updated_at`：{当前时间}
 - `agent_infra_version`：按 `.agents/rules/version-stamp.md` 取值

package/templates/.agents/skills/watch-pr/config/verify.json

@@ -15,7 +15,6 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "(Watch PR|Watching PR) \\(Round \\d+\\)"
     }
   }
 }

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.en.md

@@ -13,11 +13,11 @@ After the watch command, route by structured `readiness.state`:
 
 ## Summary Refresh Boundary
 
-Before readiness in every round, and after an external push, self-heal commit, or successful rebase changes the PR head, rerun `summary-context` → mechanical report and six-check precheck → `platform-pr change-report` → `summary-sync --change-report-file ... --result no_op --strict` with exactly one `<!-- canonical-pr-change-report -->` placeholder. `--strict` preserves report or summary refresh failures as `failed/blocked` so warnings cannot reach the ready/complete route. The core revalidates the sidecar against the authoritative PR snapshot, task-intent digest, and complete patch; missing, stale, invalid, bypassed, or raced publication must not continue to a ready/complete route and must enter the help exit with a warning.
+Before readiness in every round, and after an external push, self-heal commit, or successful rebase changes the PR head, rerun `summary-context` → mechanical report and six-check precheck → `platform-pr change-report` → update the full PR summary JSON per `.agents/rules/pr-sync.md` → `summary-sync --change-report-file ... --result no_op --strict`. `--strict` preserves report or summary refresh failures as `failed/blocked`. The core revalidates the sidecar and reads back the remote body; missing, stale, invalid, incomplete, or raced publication must not continue to a ready/complete route.
 
-When rebuilding the precheck, each of the six `rationale` fields must state the corresponding high-level finding and include at least one path, line range, and concise `detail` as evidence. `change-composition` must describe where responsibilities are concentrated; compatibility, legacy-path, redundancy, and scope checks must state their actual results separately, without reused generic boilerplate. Use the deployed skill's language for rationales and evidence details; Chinese skill deployments must use Chinese.
+When rebuilding the precheck, each of the six `rationale` fields must state its actual finding and include at least one item of evidence with a path, line range, and concise `detail`; state compatibility, legacy-path, redundancy, and scope findings separately without generic boilerplate. Use the deployed skill's language for rationales and evidence; Chinese deployments must use Chinese.
 
-Use the six existing `rationale` fields and `Evidence[]` to explain each logical change group: its goal and acceptance-criteria alignment, behavior added or removed, necessity, redundancy or duplication, scope, related tests, and test adequacy. Cite locatable code, test, or documentation evidence; mark unsupported points as unconfirmed. The renderer displays every evidence item. Source line counts, execution/call counts, and workflow unification are distinct claims: diff line counts cannot prove execution-count or workflow-behavior changes, and green CI cannot prove necessity. Analysis must not expand self-heal or refactoring authority.
+Use the candidate content contract in `.agents/skills/create-pr/reference/change-report.md` for functional grouping, per-group fields, unique line attribution, and `needs-review` criteria. Rebuild groups from the current task goal and patch on every refresh; do not reuse prior-head explanations as evidence for the current increment. Reconcile complete-PR statistics separately from the previous valid head → current head increment; explicitly mark the increment unconfirmed when no previous head can be verified. If any group lacks goal alignment, behavior added/removed, necessity, line-count reconciliation, test coverage/cost, or locatable evidence, mark `target-alignment` or `change-composition` as `needs-review` and identify the gap. Reuse the existing `nextAction=review-code` route; structural completeness or green CI must not continue to `watch-pr`.
 
 Keep complete-PR scope bound to the current authoritative base/head/merge-base/patch and its full statistics. Report the increment separately as previous valid report head → current head. Before overwriting the prior sidecar, validate it with `readPrChangeReport`; use its `identity.head.sha` only when its repository/resource identity matches the current PR. Compare the two head trees directly and state both SHAs. Do not substitute a merge-base diff for these endpoints or add increment totals to complete-PR totals. If no prior report exists, it is invalid, or its identity differs, mark the previous head unconfirmed; do not infer values from the full PR or fill in zeroes. Identical SHAs mean the head did not change. After a rebase, compare the old and new head trees. An invalid sidecar makes only the increment unconfirmed; the existing full-PR report flow continues.
 

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.zh-CN.md

@@ -13,11 +13,11 @@
 
 ## 摘要刷新边界
 
-每轮 readiness 之前，以及外部 push、自愈 commit 或 rebase 成功改变 PR head 之后，必须重新执行 `summary-context` → 机械报告与六项 precheck → `platform-pr change-report` → 含一次 `<!-- canonical-pr-change-report -->` 的 `summary-sync --change-report-file ... --result no_op --strict`。`--strict` 将报告或摘要刷新失败保留为 `failed/blocked`，不允许 warning 穿透到 ready/complete 路由。core 以权威 PR snapshot、任务意图 digest 和完整 patch 重新校验 sidecar；报告缺失、stale、invalid、占位符绕过或发布竞态时，不得继续 ready/complete 路由，转入求助出口并登记 warning。
+每轮 readiness 之前，以及外部 push、自愈 commit 或 rebase 成功改变 PR head 之后，必须重新执行 `summary-context` → 机械报告与六项 precheck → `platform-pr change-report` → 按 `.agents/rules/pr-sync.md` 更新完整 PR 摘要 JSON 并调用 `summary-sync --change-report-file ... --result no_op --strict`。`--strict` 将报告或摘要刷新失败保留为 `failed/blocked`，不允许 warning 穿透到 ready/complete 路由。core 以权威 PR snapshot、任务意图 digest 和完整 patch 重新校验 sidecar，并回读远端正文；报告缺失、stale、invalid、结构不完整或发布竞态时，不得继续 ready/complete 路由，转入求助出口并登记 warning。
 
-每轮重建 precheck 时，六项 `rationale` 都必须是对应检查的实际高层结论，并各带至少一条路径、行号和简短 `detail` 证据；`change-composition` 要说明职责集中位置，兼容、旧路径、冗余和范围检查要分别说明实际结果，禁止复用泛化套话。理由和证据详情遵循当前已部署技能的语言，中文技能必须使用中文。
+每轮重建 precheck 时，除执行下方功能级报告门槛外，六项 `rationale` 都必须陈述对应检查的实际结论，并至少带一条含路径、行号和简短 `detail` 的证据；兼容、旧路径、冗余和范围检查分别说明，不复用泛化套话。理由和证据遵循当前部署语言，中文技能必须使用中文。
 
-按逻辑变化组使用现有六项 `rationale` 和 `Evidence[]` 说明目标/验收对应、行为增减、必要性、冗余或重复、范围、相关测试及测试充分性。列出可定位的代码/测试/文档证据；缺证据时明确写未确认。renderer 会展示每项的全部 evidence。源码行数、执行/调用次数和流程统一是不同结论：diff 行数不能证明执行次数或流程行为变化；CI 全绿也不能证明必要性。不得由分析建议自行扩大自愈或重构权限。
+功能分组、逐组字段、行数唯一归属及 `needs-review` 条件统一遵循 `.agents/skills/create-pr/reference/change-report.md` 的 candidate 内容契约。每次刷新都重新按当前任务目标和 patch 建立功能组，不沿用上一 head 的说明代替本轮证据。完整 PR 统计与上一有效 head → 当前 head 的增量分开核算；没有可验证的上一 head 时明确标为未确认。任何功能组缺少目标对应、行为增减、必要性、行数对账、测试覆盖/成本或定位证据时，将 `target-alignment` 或 `change-composition` 标为 `needs-review` 并指出缺口。沿用现有 `nextAction=review-code` 路由；不得以结构完整或 CI 全绿继续 `watch-pr`。
 
 完整 PR 的范围继续绑定当前权威 base/head/merge-base/patch 与完整统计。增量单独绑定上一有效报告 head → 当前 head：在覆盖旧 sidecar 前，用 `readPrChangeReport` 校验旧报告，只在 repository/resource identity 匹配当前 PR 时采用旧 `identity.head.sha`。对两个 head 做 tree-to-tree diff 并明确列出 SHA，不用 merge-base 替代端点差异，不把增量 totals 加到完整 PR totals。没有旧报告、报告无效或身份不符时标注上一 head 未确认，不从全量推算或填零。两个 SHA 相同只报告 head 未变化；rebase 后仍比较原 head 和新 head 的树差异。sidecar 无效只使增量不可确认，不改变现有 full-PR 报告流程。
 

package/templates/.agents/templates/handoff.en.md

@@ -55,6 +55,6 @@
 
 ## References
 
-- Task file: `.agents/workspace/active/task-XXX.md`
+- Task file: `<task-workspace>/active/task-XXX.md`
 - Related docs: [links or file paths]
 - Related issues: #XXX

package/templates/.agents/templates/handoff.zh-CN.md

@@ -55,6 +55,6 @@
 
 ## 参考资料
 
-- 任务文件：`.agents/workspace/active/task-XXX.md`
+- 任务文件：`<task-workspace>/active/task-XXX.md`
 - 相关文档：[链接或文件路径]
 - 相关 Issue：#XXX

package/templates/.agents/workflows/bug-fix.en.yaml

@@ -200,4 +200,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/templates/.agents/workflows/feature-development.en.yaml

@@ -200,4 +200,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/templates/.agents/workflows/refactoring.en.yaml

@@ -204,4 +204,4 @@ steps:
       - Task workspace
     outputs:
       - Pull request (only on the PR path)
-      - Completed task workspace under .agents/workspace/completed/ after merge and final gates
+      - Completed task under `completed/{task-id}` in the host root returned by `task-workspace resolve`

package/dist/lib/task/task-execution-lock.js

@@ -1,250 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { getProcessStartTime, processIdentityMatches } from '../server/process-state.js';
-class TaskExecutionLockError extends Error {
-    code;
-    detail;
-    constructor(code, message, detail) {
-        super(message);
-        this.name = 'TaskExecutionLockError';
-        this.code = code;
-        this.detail = detail;
-    }
-}
-function errno(error) {
-    const value = error?.code;
-    return typeof value === 'string' ? value : null;
-}
-function mapLinkError(operation, error, key) {
-    const code = errno(error);
-    if (code === 'EEXIST')
-        return 'exists';
-    if (operation === 'quarantine' && code === 'ENOENT')
-        return 'missing';
-    const detail = { operation, errno: code, key };
-    if (['EPERM', 'EACCES', 'ENOSYS', 'ENOTSUP', 'EOPNOTSUPP', 'EXDEV'].includes(code ?? '')) {
-        return new TaskExecutionLockError('ORCHESTRATION_LOCK_UNSUPPORTED', `lifecycle lock hard-link operation '${operation}' is unsupported`, detail);
-    }
-    return new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', `lifecycle lock hard-link operation '${operation}' failed`, detail);
-}
-function lockKey(repoRoot, taskId, identityScope) {
-    const canonicalRepoRoot = fs.realpathSync.native(repoRoot);
-    const identity = identityScope === undefined
-        ? `${canonicalRepoRoot}\0${taskId}`
-        : `${identityScope}\0${taskId}`;
-    const key = createHash('sha256').update(identity).digest('hex');
-    return { canonicalRepoRoot, key };
-}
-function parseOwner(raw, key) {
-    try {
-        const value = JSON.parse(raw);
-        if (value !== null
-            && value.version === 2
-            && Number.isSafeInteger(value.pid)
-            && (value.pid ?? 0) > 0
-            && typeof value.startTime === 'number'
-            && Number.isSafeInteger(value.startTime)
-            && value.startTime >= 0
-            && typeof value.token === 'string'
-            && value.token.length > 0
-            && typeof value.owner === 'string'
-            && typeof value.canonicalRepoRoot === 'string'
-            && typeof value.taskId === 'string'
-            && typeof value.acquiredAt === 'string') {
-            return value;
-        }
-    }
-    catch {
-        // Fall through to the stable lock failure below.
-    }
-    throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle lock owner record is invalid', { operation: 'read', errno: null, key });
-}
-function unlinkIfPresent(file) {
-    try {
-        fs.unlinkSync(file);
-    }
-    catch (error) {
-        if (errno(error) !== 'ENOENT')
-            throw error;
-    }
-}
-function sameInode(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-function reclaimStaleLock(fixed, quarantine, snapshot, key, link) {
-    let linked = false;
-    try {
-        link(fixed, quarantine);
-        linked = true;
-    }
-    catch (error) {
-        const disposition = mapLinkError('quarantine', error, key);
-        if (disposition === 'missing')
-            return;
-        if (disposition === 'exists') {
-            try {
-                const quarantineSnapshot = fs.readFileSync(quarantine, 'utf8');
-                const fixedStat = fs.statSync(fixed);
-                const quarantineStat = fs.statSync(quarantine);
-                if (quarantineSnapshot === snapshot && sameInode(fixedStat, quarantineStat)) {
-                    unlinkIfPresent(quarantine);
-                }
-            }
-            catch (readError) {
-                if (errno(readError) !== 'ENOENT')
-                    throw readError;
-            }
-            return;
-        }
-        if (disposition instanceof TaskExecutionLockError)
-            throw disposition;
-    }
-    try {
-        const fixedSnapshot = fs.readFileSync(fixed, 'utf8');
-        const fixedStat = fs.statSync(fixed);
-        const quarantineStat = fs.statSync(quarantine);
-        if (fixedSnapshot === snapshot && sameInode(fixedStat, quarantineStat))
-            unlinkIfPresent(fixed);
-    }
-    catch (error) {
-        if (errno(error) !== 'ENOENT')
-            throw error;
-    }
-    finally {
-        if (linked)
-            unlinkIfPresent(quarantine);
-    }
-}
-function cleanStaleCandidates(lockRoot, key, identityMatches) {
-    const prefix = `${key}.candidate.`;
-    for (const name of fs.readdirSync(lockRoot)) {
-        if (!name.startsWith(prefix))
-            continue;
-        const candidate = path.join(lockRoot, name);
-        try {
-            const owner = parseOwner(fs.readFileSync(candidate, 'utf8'), key);
-            if (!identityMatches(owner))
-                unlinkIfPresent(candidate);
-        }
-        catch {
-            // A malformed candidate never owns the fixed lock and is left for manual diagnosis.
-        }
-    }
-}
-function withTaskExecutionLock(repoRoot, taskId, ownerName, callback, options = {}) {
-    let identity;
-    try {
-        identity = lockKey(repoRoot, taskId, options.identityScope);
-    }
-    catch (error) {
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'failed to canonicalize the repository for lifecycle locking', { operation: 'canonicalize', errno: errno(error), key: 'unresolved' });
-    }
-    const { canonicalRepoRoot, key } = identity;
-    const lockRoot = options.lockRoot ?? path.join(os.tmpdir(), 'agent-infra-lifecycle-locks');
-    const token = (options.token ?? randomUUID)();
-    const candidate = path.join(lockRoot, `${key}.candidate.${process.pid}.${token}`);
-    const fixed = path.join(lockRoot, `${key}.lock`);
-    const link = options.linkSync ?? fs.linkSync;
-    const startTime = (options.getStartTime ?? getProcessStartTime)(process.pid);
-    if (startTime === null) {
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'current process start time is unavailable', { operation: 'identity', errno: null, key });
-    }
-    const owner = {
-        version: 2,
-        pid: process.pid,
-        startTime,
-        token,
-        owner: ownerName,
-        canonicalRepoRoot,
-        taskId,
-        acquiredAt: (options.now ?? (() => new Date().toISOString()))()
-    };
-    const serialized = `${JSON.stringify(owner)}\n`;
-    let ownsFixed = false;
-    let deferRelease = false;
-    const release = () => {
-        try {
-            unlinkIfPresent(candidate);
-        }
-        catch {
-            // Candidate cleanup is best-effort and must not replace the primary result.
-        }
-        if (ownsFixed) {
-            try {
-                const current = parseOwner(fs.readFileSync(fixed, 'utf8'), key);
-                if (current.token === token)
-                    unlinkIfPresent(fixed);
-            }
-            catch {
-                // A missing or replaced fixed lock is not owned by this invocation.
-            }
-        }
-    };
-    try {
-        fs.mkdirSync(lockRoot, { recursive: true });
-        cleanStaleCandidates(lockRoot, key, options.identityMatches ?? processIdentityMatches);
-        const descriptor = fs.openSync(candidate, 'wx', 0o600);
-        try {
-            fs.writeFileSync(descriptor, serialized);
-            fs.fsyncSync(descriptor);
-        }
-        finally {
-            fs.closeSync(descriptor);
-        }
-        for (let attempt = 0; attempt < 16; attempt += 1) {
-            try {
-                link(candidate, fixed);
-                ownsFixed = true;
-                break;
-            }
-            catch (error) {
-                const disposition = mapLinkError('acquire', error, key);
-                if (disposition instanceof TaskExecutionLockError)
-                    throw disposition;
-                let snapshot;
-                let current;
-                try {
-                    snapshot = fs.readFileSync(fixed, 'utf8');
-                    current = parseOwner(snapshot, key);
-                }
-                catch (readError) {
-                    if (errno(readError) === 'ENOENT')
-                        continue;
-                    throw readError;
-                }
-                if ((options.identityMatches ?? processIdentityMatches)(current)) {
-                    throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'another lifecycle operation holds the task lock', { operation: 'acquire', errno: 'EEXIST', key });
-                }
-                reclaimStaleLock(fixed, `${fixed}.quarantine.${current.token}`, snapshot, key, link);
-            }
-        }
-        if (!ownsFixed) {
-            throw new TaskExecutionLockError('ORCHESTRATION_LOCK_BUSY', 'lifecycle task lock could not be acquired after stale recovery', { operation: 'acquire', errno: 'EEXIST', key });
-        }
-        unlinkIfPresent(candidate);
-        const value = callback();
-        if (value && typeof value.then === 'function') {
-            deferRelease = true;
-            return value.finally(release);
-        }
-        return value;
-    }
-    catch (error) {
-        if (error instanceof TaskExecutionLockError)
-            throw error;
-        if (error instanceof Error && ['OrchestrationStateError', 'ArtifactRecoveryError'].includes(error.name))
-            throw error;
-        throw new TaskExecutionLockError('ORCHESTRATION_LOCK_FAILED', 'lifecycle task lock operation failed', { operation: ownsFixed ? 'callback' : 'acquire', errno: errno(error), key });
-    }
-    finally {
-        if (!deferRelease)
-            release();
-    }
-}
-function withRepositoryMutationLock(repoRoot, callback, options = {}) {
-    return withTaskExecutionLock(repoRoot, '__repository_mutation__', 'repository-mutation', callback, options);
-}
-export { TaskExecutionLockError, lockKey, mapLinkError, withRepositoryMutationLock, withTaskExecutionLock };
-//# sourceMappingURL=task-execution-lock.js.map