@fitlab-ai/agent-infra 0.9.8 → 0.9.10

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

@@ -1,169 +1,85 @@
 ---
 name: commit
 description: >
-  Commit the current changes to Git.
-  Use when finished work needs to be turned into a Git commit.
+  Commit current changes to Git.
+  Use when completed work needs to be recorded as a Git commit.
 ---
 
-# Commit Changes
-> `--agent` values follow the "Collaborator Token Specification" in `.agents/rules/task-management.md`: standard AI short tokens (`claude`/`codex`/`antigravity`/`opencode`/`cursor`), long-name normalization (`claude-code`->`claude`, `antigravity-cli`->`antigravity`), or the `human` manual exception.
+# Commit code
 
+Use the standard agent token from `.agents/rules/task-management.md`.
 
-Create a Git commit without overwriting user work and update the related task state when needed.
+Create a Git commit without overwriting local work, and update the associated task only when a task context exists.
 
-When updating related `task.md` frontmatter, read `.agents/rules/version-stamp.md` first and write or refresh `agent_infra_version`.
+The commit core returns one primary result: `committed`, `no_op`, `committed_with_warnings`, `failed`, or `blocked`, with structured `warnings`. A push failure or protected-branch policy never rolls back a local commit.
 
-When the entry business operands literally contain `--orchestrated`, bind `{execution-flag}` to `--orchestrated`; otherwise bind it to empty. Never infer the source from a run file or environment.
+## Task context
 
-Direct invocation still requires explicit user authorization. An orchestrated invocation may continue only after the commit intent validates its activated receipt and one-use `commitAuthorization` before side effects; every other commit gate remains unchanged.
+Resolve the optional task scope with `agent-infra-internal task-context resolve {task-scope}`.
 
-## Common Rationalizations and Rebuttals
+- An explicit task-resolution failure stops the operation.
+- Without an explicit task scope, only `TASK_CONTEXT_NOT_FOUND` may enter taskless direct mode; detached HEAD, malformed candidates, and multiple matches fail closed.
+- If the literal `--orchestrated` is present in the business operands, use `mode=orchestrated`; otherwise use `mode=direct`. Never infer the mode from files or environment.
+- Taskless direct mode does not read, create, or complete task intent, receipt, checkpoint, or task.md records.
+- Task-bound direct mode does not require a delegation receipt; orchestrated mode must validate the matching activated commit receipt and capability in the core.
+- After resolution, use only the core-returned `taskId`; never infer task identity from the environment, branch, or filename.
 
-| Rationalization | Rebuttal |
-|------|------|
-| "The tests already ran earlier, so I do not need to rerun them." | The staged content is the current truth; before committing, re-check `git status` and `git diff` instead of relying on memory. |
-| "`git add -A` is faster." | `git add -A` and `git add .` are forbidden; stage only explicitly listed files to avoid including unrelated changes. |
-| "This file has a copyright header, but the year can wait." | If you changed it, update the copyright year using `date +%Y`; this is a hard pre-commit check. |
+## 1. Inspect local changes
 
-## Task Context Resolution
-
-> The entry point may omit the task ref and also accepts a legacy positional ref or `--task <ref>` / `-t <ref>`. Separate task scope from the full arguments while preserving every business operand, then call `agent-infra-internal task-context resolve {task-scope}` where `{task-scope}` is empty, one positional ref, or one task flag. Read only `taskId` from the structured result and bind `{task-id}` to that full `TASK-YYYYMMDD-HHMMSS` for downstream commands. Pass through resolution failures without scanning tasks locally.
-
-Without explicit task scope, only `TASK_CONTEXT_NOT_FOUND` may continue through the existing bare-commit path. Detached HEAD, damaged candidates, or multiple matches are ambiguity errors. Any explicit task-scope failure is fatal.
-
-## Step Start: Recover or Create a Controlled Attempt
-
-When `{task-id}` is resolved, call `commit-status` first. Finalize `recoverable`; safely clear `prepared` and query status again; reuse `retryable-start` through `commit-recover --agent {standard-agent-token}`. Fail closed for `invalid` / `conflict` / `orphaned-start`. For `idle`, call `commit-start --agent {standard-agent-token}` so the core atomically writes the structured started entry and returns its attempt/baseline.
-
-Read `{commit-attempt}` only from structured `commit-start` / `commit-recover` output. Never hand-write, copy, or guess an attempt. A bare commit without task context skips this protocol.
-
-## 1. Check Local Modifications (CRITICAL)
-
-Before any edit, inspect:
+Before editing, run:
 
 ```bash
 git status --short
 git diff
 ```
 
-Respect existing user changes. If your planned edit conflicts with them, stop and ask before proceeding.
-
-## 2. Update Copyright Headers
-
-Use the current year dynamically and only update files that are already modified.
-
-> The full copyright workflow lives in `reference/copyright-check.md`. Read `reference/copyright-check.md` before editing any header.
-
-## 3. Build the Commit Message
-
-Review status, diff, and recent history, then prepare a Conventional Commit with the correct co-author lines.
-
-> Commit message rules, examples, and multi-agent co-authorship details live in `reference/commit-message.md`. Read `reference/commit-message.md` before writing the commit.
-
-## 4. Create the Commit
-
-When `{task-id}` was resolved, read `reference/commit-orchestration.md` before this step and complete `commit-begin` before any successful Git/platform side effect. A taskless Git-only commit skips the intent protocol entirely.
-
-Detect the restricted push-only scenario first. Otherwise write message, explicit paths, and expected HEAD/tree to JSON and call `agent-infra-internal git-workflow commit --input {file}`.
-
-Immediately after a normal commit succeeds, run the committed checkpoint from that reference. If the checkpoint fails, retain the intent and stop before push or success-state writes.
-
-If this commit is associated with a task and a `review-code` artifact exists, read the highest-round `review-code` artifact before committing:
-- If that artifact's `Overall Verdict` / `总体结论` is Approved, parse `R`, `F`, and `Reviewed Snapshot Tree` / `审查快照树` (`T`)
-- After staging the explicit files, record `pre_head=$(git rev-parse HEAD)` and use the helper's JSON mode to generate the complete worktree tree `W` and normalized staged tree `S`
-- Before `git commit`, require `pre_head == R && W == T && S == T`; use the helper's `compare` mode to produce added, missing, and different diagnostics for both worktree and staged snapshots
-- If any condition fails, enter Scenario 4 in `reference/task-status-update.md`; do not run `git commit`, push, successful state updates, PR summary sync, or the completion gate
-- After all comparisons match and the commit succeeds, the Step 6 `commit-complete` core finalizer atomically writes `last_reviewed_commit` and Commit done; the caller must not write them
-- Do not scan backward to earlier Approved artifacts; the highest-round `review-code` artifact is the only authoritative source
-
-## 5. Push to the Existing PR When Applicable
+Respect existing user changes and stop on a conflict according to the no-mid-flow-questions rule.
 
-After a new commit is created, or when Step 4 selects push-only, push HEAD normally if the current branch already has an open Pull Request. Otherwise keep the current behavior (the first push is still handled by `create-pr`). This adds no extra/empty commit and never pushes when there is no PR.
+## 2. Update copyright years
 
-> Detect whether the current branch has an open PR — and authenticate to the platform — per `.agents/rules/issue-pr-commands.md`; if that rule is unavailable or detection fails, follow the degradation below.
+Get the current year dynamically and update only touched files that contain a copyright header. Read `reference/copyright-check.md` for the complete procedure.
 
-a. Detect whether the current branch (head) has an open PR per `.agents/rules/issue-pr-commands.md`.
+## 3. Create the commit message
 
-b. On an open PR -> push the current branch:
+Review status, diff, and recent history. Use an imperative Conventional Commit message and read `reference/commit-message.md` for co-author handling.
 
-Use `agent-infra-internal git-workflow push --input {file}` for per-ref normal push and verification. Never force push.
+## 4. Call the single commit core
 
-After push succeeds and remote verification completes, immediately run the pushed checkpoint from `reference/commit-orchestration.md`.
+Read `reference/commit-orchestration.md` before this step.
 
-c. Safe degradation (never block an already completed `git commit`; only warn the user):
-   - Platform unavailable / unauthenticated / detection failed / no open PR -> do not push; continue.
-   - `git push` fails (needs `git pull --rebase`, no upstream, network error) -> keep the local commit and tell the user to push manually.
-
-Fold the push outcome (pushed / skipped(no PR) / failed) into the next step's "Update Task Status" Activity Log note or user output.
-
-## 6. Update Task Status When Applicable
-
-After checkpoints and before synchronization or the completion gate, call `commit-complete`. Under the task lock, core writes the review anchor, Commit done, and planned orchestration bytes, then deletes the intent last. On failure retain the intent and let the next skill run use status/recover.
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-complete --token "$commit_intent_token" --agent {standard-agent-token}
-```
-
-Get the current time:
+Write the message, explicit paths, expected HEAD/tree, task scope, agent, mode, and optional push policy to a temporary JSON file, then call:
 
 ```bash
-date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
+agent-infra-internal git-workflow commit --input {commit-operation.json}
 ```
 
-> The full five-case status matrix, prerequisite checks, and multi-TUI next-step commands live in `reference/task-status-update.md`. Read `reference/task-status-update.md` before updating task state.
-
-> Before rendering next steps, read `.agents/rules/next-step-output.md` and invoke the shared helper for the scenario selected from `reference/task-status-update.md`.
-
-After core finalization succeeds, choose exactly one next-step case:
-- open PR and successful push -> `watch-pr {task-ref}`; this takes precedence over the final-commit `prFlow` route
-- failed push -> keep the task active and show only push/synchronization diagnostics; do not show `watch-pr` or `complete-task`
-- final commit -> render the next step by `.agents/.airc.json`'s `prFlow` (`disabled` -> single option `complete-task`; `required` -> single option `create-pr`; absent -> two options `create-pr` / `complete-task`); see Case 1 in `reference/task-status-update.md`
-- more work remains -> update task.md and stop
-- ready for review -> `review-code {task-id}`
+Taskless direct mode omits `taskRef`; orchestrated mode must pass `taskRef`, `agent`, and `mode: "orchestrated"`. The core owns repository/worktree mutation locking, task locking when bound, path and sensitive-file checks, staged scope, HEAD/tree, branch/ref, commit, push, protected-branch policy, warnings, and idempotency.
 
-## 7. Sync Issue Metadata When Applicable
+- Create at most one local commit for explicit changes.
+- If there are no changes but HEAD is ahead and delivery is requested, perform push-only and do not create an empty commit.
+- Skip automatic push on `main` / `master` with `COMMIT_AUTOPUSH_PROTECTED_BRANCH`; retain the local commit.
+- Return `COMMIT_PUSH_FAILED` as a warning on ordinary push failure; a retry only repairs push and never creates a second commit.
+- Successful taskless operations write no task.md, review, receipt, checkpoint, or Activity Log record.
 
-When `{task-id}` exists and task.md contains a valid `issue_number`, sync the linked Issue `in:` labels and requirement checkboxes. Otherwise, skip this step.
+## 5. Finish task and platform synchronization
 
-> Trigger conditions and the declarative `platform-issue` call live in `reference/issue-metadata-sync.md`. Read that file before running this step.
->
-> If this step touches the code-hosting platform, complete the prerequisite checks in `.agents/rules/issue-pr-commands.md` first.
+Continue task synchronization only for task-bound operations. For an associated Issue or PR, follow the issue, PR-summary, and platform rules; the commit path passes `--result no_op` to summary-sync because it only synchronizes an existing PR identity. Synchronization failures are warnings and do not roll back the local commit.
 
-Failure handling matches "Update Task Status When Applicable": warn, but do **not** block an already completed `git commit`.
-
-## 8. Sync PR Summary When Applicable
-
-When `{task-id}` exists and task.md contains a valid `pr_number`, refresh the PR summary comment marked with the PR summary marker defined in `.agents/rules/pr-sync.md` on the PR. Otherwise, skip this step.
-
-> The full trigger conditions, aggregation rules, PATCH/POST flow, shell-safety constraints, and error handling live in `reference/pr-summary-sync.md` (which in turn points to `.agents/rules/pr-sync.md`). Read `reference/pr-summary-sync.md` before executing this step.
->
-> If this step touches the code-hosting platform, complete the prerequisite checks in `.agents/rules/issue-pr-commands.md` first so the runtime context required by `.agents/rules/pr-sync.md` is ready.
-
-Failure handling matches "Update Task Status When Applicable": warn, but do **not** block an already completed `git commit`.
-
-## 9. Verification Gate
-
-If this operation is associated with `{task-id}`, run the verification gate to confirm task metadata and sync state. If there is no task context, skip this step.
+After task-bound finalization, run:
 
 ```bash
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 agent-infra-internal task-verify {task-id} commit.completed --format text
 ```
 
-Handle the result as follows:
-- exit code 0 (all checks passed) -> continue the remaining wrap-up steps
-- exit code 1 (validation failed) -> fix the reported issues and run the gate again
-- exit code 2 (network blocked) -> stop and tell the user that human intervention is required
+Do not claim task finalization without fresh verification output.
 
-Keep the gate output in your reply as fresh evidence. Do not claim completion without output from this run.
+## 6. Render the next step
 
-Run this gate only after core finalization succeeds; never place it before `commit-complete`.
+Read `.agents/rules/next-step-output.md` immediately before calling the single next-step helper. A failed push keeps the task active and reports diagnostics; a final commit routes to `create-pr` or `complete-task` according to `prFlow`.
 
 ## Notes
 
-- Never commit secrets such as `.env`, credentials, or keys
-- Keep the current agent first in the co-author block
-- Do not use `git add -A` or `git add .`
-
-## Error Handling
-
-- If the task status update fails, warn the user but do not block the commit
+- Never commit `.env`, credentials, keys, or other sensitive files.
+- Never use `git add -A` or `git add .`.
+- Never hand-write task Activity Log, review anchors, receipts, or checkpoints.

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

@@ -6,44 +6,25 @@ description: >
 ---
 
 # 提交代码
-> `--agent` 取值见 `.agents/rules/task-management.md`「合作者 token 规范」：标准 AI 短名（`claude`/`codex`/`antigravity`/`opencode`/`cursor`）、长名归一化（`claude-code`→`claude`、`antigravity-cli`→`antigravity`）或人工例外 `human`。
 
+> `--agent` 取值见 `.agents/rules/task-management.md`「合作者 token 规范」。
 
 在不覆盖用户本地工作的前提下创建 Git commit，并在需要时更新关联任务状态。
 
-更新关联 `task.md` frontmatter 时，先读取 `.agents/rules/version-stamp.md`，并写入或刷新 `agent_infra_version`。
+commit core 只返回一个主结果：`committed`、`no_op`、`committed_with_warnings`、`failed` 或 `blocked`，并附带结构化 `warnings`。push 失败或保护分支策略不会撤销已经创建的本地提交。
 
-若入口业务操作数包含字面 `--orchestrated`，绑定 `{execution-flag}` = `--orchestrated`；否则绑定为空。不得从 run 文件或环境推断来源。
+## 任务上下文
 
-直接调用仍要求用户显式授权。编排调用只有在副作用前通过 commit intent 对 activated receipt 与一次性 `commitAuthorization` 的联合校验后才可继续，其他提交门禁保持不变。
+入口允许省略 task ref，也接受旧位置 task ref 或 `--task <ref>` / `-t <ref>`。先调用 `agent-infra-internal task-context resolve {task-scope}`。
 
-## 常见违规借口与反驳
+- 显式 task scope 解析失败时停止。
+- 未显式指定 task scope 时，只有 `TASK_CONTEXT_NOT_FOUND` 可进入 taskless direct；detached HEAD、损坏候选或多匹配必须 fail closed。
+- 入口业务操作数包含字面 `--orchestrated` 时使用 `mode=orchestrated`，否则使用 `mode=direct`；不得从 run 文件或环境推断模式。
+- taskless direct 不读取、创建或完成 task intent、receipt、checkpoint 或 task.md 收尾记录。
+- task-bound direct 不要求 delegation receipt；orchestrated 必须由 core 验证匹配的 activated commit receipt 和 capability。
+- 解析成功后只使用 core 返回的 `taskId`；不得从环境、分支或文件名猜测任务身份。
 
-| 借口 | 反驳 |
-|------|------|
-| 「测试之前跑过了，不用重跑」 | 暂存内容是最新现实；提交前必须重新核对 `git status`/`git diff`，不能凭记忆。 |
-| 「`git add -A` 更省事」 | 禁止 `git add -A`/`git add .`；只暂存明确列出的文件，避免带入无关改动。 |
-| 「改了带版权头的文件，年份先不动」 | 改了就更新版权年份（动态取 `date +%Y`），这是提交前的硬性检查。 |
-
-## 任务上下文解析
-
-> 入口允许省略 task ref，也接受旧位置 task ref 或 `--task <ref>` / `-t <ref>`。先从完整参数中分离 task scope 并原样保留其他业务操作数，再调用 `agent-infra-internal task-context resolve {task-scope}`；`{task-scope}` 为空、位置 ref 或 task flag 之一。只读取结构化结果的 `taskId`，后续把 `{task-id}` 绑定为该完整 `TASK-YYYYMMDD-HHMMSS`。解析失败时透传非零退出码，不自行扫描任务。
-
-未显式指定 task scope 时，只有 `TASK_CONTEXT_NOT_FOUND` 可继续既有纯提交路径；detached HEAD、损坏候选或多匹配属于歧义，必须失败。显式 task scope 解析失败时一律失败。
-
-## 步骤开始：恢复或创建受控 attempt
-
-已解析出 `{task-id}` 时，先调用 `agent-infra-internal task-orchestration {task-id} commit-status`：
-
-- `recoverable`：调用 `commit-recover --agent {standard-agent-token}` 完成收尾，不得重复 commit 或 push。
-- `prepared`：调用 `commit-recover --agent {standard-agent-token}` 安全清理 intent，再次查询 status 并复用返回的 `retryable-start` attempt。
-- `retryable-start`：调用 `commit-recover --agent {standard-agent-token}` 取得原 attempt，不追加第二条 started。
-- `invalid` / `conflict` / `orphaned-start`：输出结构化 code 与状态证据并停止。
-- `idle`：调用 `commit-start --agent {standard-agent-token}`，由核心在任务锁内原子写入结构化 started 并返回 attempt/baseline。
-
-只从 `commit-start` / `commit-recover` 的结构化输出读取 `{commit-attempt}`；不得手写、复制或猜测 attempt。无任务上下文的纯提交跳过本协议。
-
-## 1. 检查本地修改（关键）
+## 1. 检查本地修改
 
 在任何编辑前先检查：
 
@@ -52,126 +33,74 @@ git status --short
 git diff
 ```
 
-必须尊重现有用户改动；如果你的计划与之冲突，先停止并征求确认。
+必须尊重现有用户改动；如果计划与之冲突，按禁言规则停止并记录阻塞原因。
 
 ## 2. 更新版权头年份
 
-动态获取当前年份，只更新已经改动过的文件。
-
-> 完整版权检查流程见 `reference/copyright-check.md`。修改任何版权头前，先读取 `reference/copyright-check.md`。
+动态获取当前年份，只更新已经改动过的带版权头文件。完整流程见 `reference/copyright-check.md`。
 
 ## 3. 生成提交信息
 
-检查状态、diff 和最近历史，然后按 Conventional Commits 生成 message，并补齐正确的协作署名。
-
-> 提交信息规则、示例和多代理署名细节见 `reference/commit-message.md`。写 commit message 前先读取 `reference/commit-message.md`。
-
-## 4. 创建提交
-
-已解析出 `{task-id}` 时，执行本步骤前先读取 `reference/commit-orchestration.md`，并在任何 Git/平台成功副作用前完成 `commit-begin`；无任务上下文的纯 Git 提交完全跳过 intent 协议。
-
-先判断受限 push-only 场景；否则把 message、显式路径、expected HEAD/tree 写入临时 JSON，并调用 `agent-infra-internal git-workflow commit --input {file}`。core 负责范围、敏感文件、暂存树和幂等校验。
-
-普通 commit 成功后必须立即按该 reference 执行 committed checkpoint；checkpoint 失败时保留 intent 并停止，不得继续 push 或写成功状态。
-
-如果本次提交关联任务且存在 `review-code` 产物，在提交前读取最高轮 `review-code` 产物：
-- 若该产物 `总体结论` / `Overall Verdict` 为 Approved，解析 `R`、`F` 与 `审查快照树` / `Reviewed Snapshot Tree`（`T`）
-- 暂存明确文件后记录 `pre_head=$(git rev-parse HEAD)`，并以 helper 的 JSON 模式生成当前完整工作区树 `W` 与规范化暂存树 `S`
-- 在 `git commit` 前要求 `pre_head == R && W == T && S == T`；分别运行 helper 的 `compare` 模式生成 worktree/staged 的 added、missing、different 路径诊断
-- 任一条件不满足时进入 `reference/task-status-update.md` 的“场景 4：提交前快照阻断”，不得执行 `git commit`、push、成功状态更新、PR 摘要同步或完成 gate
-- 全部相等并成功提交后，由步骤 6 的 `commit-complete` 核心收尾原子写入 `last_reviewed_commit` 与 Commit done；调用方不得手写
-- 不向后扫描更早的 Approved 产物；最高轮 `review-code` 产物是唯一权威来源
-
-## 5. 推送到已有 PR（按需）
-
-新提交完成或步骤 4 命中 push-only 后，如果当前分支已存在开放的 Pull Request，则把 HEAD 普通推送上去让 PR 自动更新；否则保持现状（首次推送仍由 `create-pr` 负责）。本步骤不创建额外/空 commit，也不在无 PR 时推送；与是否关联任务无关。
-
-> 检测当前分支是否有开放 PR、以及平台认证，统一按 `.agents/rules/issue-pr-commands.md` 执行；该规则不可用或检测失败时，按下方降级处理。
-
-a. 按 `.agents/rules/issue-pr-commands.md` 检测当前分支（head）是否存在开放 PR。
+检查状态、diff 和最近历史，按 Conventional Commits 生成英文祈使句 message，并读取 `reference/commit-message.md` 处理协作署名。
 
-b. 命中开放 PR -> 推送当前分支：
+## 4. 调用唯一 commit core
 
-通过 `agent-infra-internal git-workflow push --input {file}` 逐 ref 普通推送并复核，禁止 force push。
+执行本步骤前读取 `reference/commit-orchestration.md`。
 
-推送成功并完成远端复核后，必须立即按 `reference/commit-orchestration.md` 执行 pushed checkpoint。
-
-c. 安全降级（不阻塞已完成的 `git commit`，仅提示用户）：
-   - 平台不可用 / 未认证 / 检测失败 / 未命中开放 PR -> 不推送，继续后续步骤。
-   - `git push` 失败（如需 `git pull --rebase`、无 upstream、网络异常）-> 保留本地提交，提示用户手动推送。
-
-把推送结果（pushed / skipped(no PR) / failed）并入下一步「更新任务状态」的 Activity Log 说明或用户输出。
-
-## 6. 按需更新任务状态
-
-普通 commit/push checkpoint 完成后，先调用核心收尾；它在同一任务锁内写入审查锚点、Commit done 与 orchestration planned bytes，最后删除 intent：
+将 message、明确 paths、expected HEAD/tree、task scope、agent、mode 和可选 push policy 写入临时 JSON，然后调用：
 
 ```bash
-agent-infra-internal task-orchestration {task-id} commit-complete --token "$commit_intent_token" --agent {standard-agent-token}
+agent-infra-internal git-workflow commit --input {commit-operation.json}
 ```
 
-失败时保留 intent，输出 `commit-status` 后停止；重跑本技能由开头的 status/recover 路由恢复。调用方不得重复追加 Commit done 或修改 `last_reviewed_commit`。
-
-获取当前时间：
-
-```bash
-date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
+示例：
+
+```json
+{
+  "taskRef": "TASK-YYYYMMDD-HHMMSS",
+  "agent": "codex",
+  "mode": "direct",
+  "paths": ["lib/example.ts", "tests/example.test.ts"],
+  "message": "fix(core): validate example input",
+  "expectedHead": "{HEAD}",
+  "expectedTree": "{TREE}",
+  "push": {
+    "remote": "origin",
+    "refs": ["refs/heads/{branch}"],
+    "automatic": true
+  }
+}
 ```
 
-> 完整的 5 种状态分支、前置条件检查和多 TUI 下一步命令见 `reference/task-status-update.md`。更新任务状态前，先读取 `reference/task-status-update.md`。
-
-> 渲染下一步前先读取 `.agents/rules/next-step-output.md`，并按 `reference/task-status-update.md` 的已选场景调用统一 helper。
+taskless direct 省略 `taskRef`；orchestrated 必须显式传 `taskRef`、`agent` 和 `mode: "orchestrated"`。core 统一负责 repository/worktree mutation lock、task lock（仅 task-bound）、路径和敏感文件、staged scope、HEAD/tree、branch/ref、commit、push、保护分支、warning 和幂等校验。
 
-核心收尾成功后只能选择一个下一步分支：
-- 已有开放 PR 且 push 成功 -> `watch-pr {task-ref}`；该分支优先于最终提交的 `prFlow` 路由
-- push 失败 -> 保持任务 active，只输出推送/同步诊断，不输出 `watch-pr` 或 `complete-task`
-- 最终提交 -> 按 `.agents/.airc.json` 的 `prFlow` 渲染下一步（`disabled` → 单选 `complete-task`；`required` → 单选 `create-pr`；缺省 → 二选一 `create-pr` / `complete-task`），详见 `reference/task-status-update.md` 场景 1
-- 还有后续工作 -> 更新 task.md 后停止
-- 准备审查 -> `review-code {task-id}`
+- 有明确修改时最多创建一个本地 commit。
+- 无修改但需要交付本地领先的 HEAD 时只执行 push-only，不创建空 commit。
+- `main` / `master` 的自动 push 跳过并返回 `COMMIT_AUTOPUSH_PROTECTED_BRANCH`；本地 commit 保留。
+- 普通 push 失败返回 `COMMIT_PUSH_FAILED` warning；重跑只补当前 push，不重复创建 commit。
+- taskless 成功不写 task.md、review、receipt、checkpoint 或 Activity Log。
 
-## 7. 同步 Issue 元数据（按需）
+## 5. 任务收尾与平台同步
 
-当 `{task-id}` 存在且 task.md 包含有效 `issue_number` 时，同步 `in:` label 和需求复选框到关联 Issue；否则跳过。
+task-bound 操作按 core 返回的 task 结果继续执行任务同步；taskless 操作跳过任务校验和任务平台同步。
 
-> 触发条件与声明式 `platform-issue` 调用见 `reference/issue-metadata-sync.md`。执行前先读取该文件。
->
-> 如果本步骤会访问代码托管平台，则先按 `.agents/rules/issue-pr-commands.md` 完成前置检测。
+当 task 存在且关联 Issue/PR 时，按 `reference/issue-metadata-sync.md`、`reference/pr-summary-sync.md` 和平台规则执行同步；commit 路径调用 summary-sync 时固定传入 `--result no_op`，因为它只同步已有 PR 身份。同步失败只产生 warning，不撤销本地 commit。
 
-失败处理与「按需更新任务状态」一致：警告但**不**阻塞已完成的 `git commit`。
-
-## 8. 同步 PR 摘要（按需）
-
-当 `{task-id}` 存在且 task.md 包含有效 `pr_number` 时，刷新 PR 上由 `.agents/rules/pr-sync.md` 中定义的 PR 摘要评论标记对应的摘要评论；否则跳过。
-
-> 完整的触发条件、聚合规则、PATCH/POST 流程、Shell 安全约束和错误处理见 `reference/pr-summary-sync.md`（其内联引用 `.agents/rules/pr-sync.md`）。执行此步骤前先读取 `reference/pr-summary-sync.md`。
->
-> 如果本步骤会访问代码托管平台，则先按 `.agents/rules/issue-pr-commands.md` 完成前置检测，确保 `.agents/rules/pr-sync.md` 所需的运行时上下文已就绪。
-
-失败处理与「按需更新任务状态」一致：警告但**不**阻塞已完成的 `git commit`。
-
-## 9. 完成校验
-
-如果本次操作关联了 `{task-id}`，运行完成校验，确认任务元数据和同步状态符合规范；如果没有任务上下文，跳过本步骤。
+完成 task-bound 收尾后运行：
 
 ```bash
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 agent-infra-internal task-verify {task-id} commit.completed --format text
 ```
 
-处理结果：
-- 退出码 0（全部通过）-> 继续后续收尾步骤
-- 退出码 1（校验失败）-> 根据输出修复问题后重新运行校验
-- 退出码 2（网络中断）-> 停止执行并告知用户需要人工介入
+没有当次校验输出，不得声明任务收尾完成。
 
-将校验输出保留在回复中作为当次验证输出。没有当次校验输出，不得声明完成。
+## 6. 输出下一步
 
-本 gate 只在步骤 6 核心收尾成功后运行；不得把完成校验放在 `commit-complete` 之前。
+渲染下一步前先读取 `.agents/rules/next-step-output.md`，并根据最新 task/PR 状态只调用一次统一 helper。push 失败时保持任务 active，只输出诊断；最终提交则按 `prFlow` 选择 `create-pr` 或 `complete-task`。
 
 ## 注意事项
 
-- 不要提交 `.env`、凭据、密钥等敏感文件
-- 协作署名中当前代理必须排在最前面
-- 不要使用 `git add -A` 或 `git add .`
-
-## 错误处理
-
-- 如果任务状态更新失败，警告用户，但不要因此阻止提交
+- 不要提交 `.env`、凭据、密钥等敏感文件。
+- 不要使用 `git add -A` 或 `git add .`。
+- 不要手写 task Activity Log、review anchor、receipt 或 checkpoint。

package/templates/.agents/skills/commit/reference/commit-message.en.md

@@ -40,7 +40,7 @@ Build the co-author block with these rules:
 ## Create the Commit
 
 ```bash
-agent-infra-internal git-workflow commit --input {commit-intent.json}
+agent-infra-internal git-workflow commit --input {commit-operation.json}
 ```
 
 Important:

package/templates/.agents/skills/commit/reference/commit-message.zh-CN.md

@@ -40,7 +40,7 @@ git log --oneline -5
 ## 创建提交
 
 ```bash
-agent-infra-internal git-workflow commit --input {commit-intent.json}
+agent-infra-internal git-workflow commit --input {commit-operation.json}
 ```
 
 重要约束：

package/templates/.agents/skills/commit/reference/commit-orchestration.en.md

@@ -1,50 +1,21 @@
-# Commit Orchestration Coordination
+# Commit core boundary
 
-This protocol applies only when `{task-id}` was resolved. A taskless Git-only commit must not read, create, or complete a commit intent.
+Commit, push, result mapping, and task finalization use one `commit-operation.execute`. The entry point only resolves task scope, explicit agent, and the literal `--orchestrated`; it never infers the source from state files.
 
-## Execution source
+## Entry modes
 
-- Bind `{execution-flag}` to `--orchestrated` only when that literal flag appears in the entry business operands.
-- Every other invocation is standalone. Never infer the source from `orchestration.json`, environment variables, or activity history.
+- `mode=direct`: explicit user invocation is the authorization. Task-bound direct may read task facts but does not require a delegation receipt; taskless direct is allowed only for `TASK_CONTEXT_NOT_FOUND` and skips task facts, review, task lock, checkpoint, and task.md finalization.
+- `mode=orchestrated`: an explicit task is required. Before the first Git write, the core validates the matching activated commit receipt, agent, stage, round, artifact, role, and unconsumed capability. Missing evidence returns `blocked` without writing Git.
 
-## Begin before side effects
+## Shared order
 
-Call `commit-status` whenever the commit skill starts. Use `commit-recover --agent {standard-agent-token}` for `recoverable` / `prepared` / `retryable-start`; use `commit-start --agent {standard-agent-token}` for `idle`; fail closed for every other state. Read `commit_attempt` only from `finalization.attempt.attempt` in start/recover output.
+1. Acquire the repository/worktree mutation lock; task-bound execution also acquires the task lock.
+2. Validate the repository, current branch, explicit paths, sensitive paths, staged scope, expected HEAD/tree, remote, and full heads ref.
+3. Validate the authorization for the selected mode.
+4. Create at most one local commit; with no changes, allow push-only and never create an empty commit.
+5. Return `COMMIT_AUTOPUSH_PROTECTED_BRANCH` on protected automatic push, or `COMMIT_PUSH_FAILED` on ordinary push failure, while retaining local facts.
+6. Return one primary result: `committed`, `no_op`, `committed_with_warnings`, `failed`, or `blocked`.
 
-After read-only preparation of status, copyright, message, review snapshot, and push routing, record `baseline_head=$(git rev-parse HEAD)` and run this before any commit, push, success log, or platform success sync:
+## Retry boundary
 
-```bash
-commit_intent_result=$(agent-infra-internal task-orchestration {task-id} commit-begin --agent {standard-agent-token} {execution-flag} --baseline-head "$baseline_head" --attempt "$commit_attempt")
-commit_intent_token=$(printf '%s' "$commit_intent_result" | node -e 'let input = ""; process.stdin.on("data", chunk => input += chunk).on("end", () => process.stdout.write(JSON.parse(input).token))')
-```
-
-Set `commit_intent_token` from the one-use `token` in structured output and keep it only in the current process. A failed begin forbids all later side effects.
-
-## Side-effect checkpoints
-
-Immediately after a normal commit succeeds, record its new HEAD:
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-checkpoint --token "$commit_intent_token" --kind committed --head "$new_head"
-```
-
-Immediately after a push succeeds and remote verification completes, record the verified remote/ref/HEAD:
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-checkpoint --token "$commit_intent_token" --kind pushed --head "$pushed_head" --remote "$remote" --ref "$ref"
-```
-
-A push-only path skips the committed checkpoint; its pushed HEAD must equal the begin baseline.
-
-## Completion and recovery
-
-After the committed/pushed checkpoint and before task synchronization or `task-verify commit.completed`, run:
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-complete --token "$commit_intent_token" --agent {standard-agent-token}
-```
-
-- If an intent exists but no side effect occurred, use `commit-abort --token ... --expected-head ...` while HEAD still equals baseline; when abandoning the attempt, then close it with `commit-terminate --attempt "$commit_attempt" --agent {standard-agent-token} --code <STABLE_CODE>`.
-- If begin failed before intent creation, retain the attempt for retry or terminate it only while HEAD is unchanged.
-- After a commit or push, never abort. Retain the intent and use `commit-status` / `commit-recover` for cross-session recovery.
-- Stop when `commit-complete` fails. Do not repeat commit/push or mark a run complete without its full receipt lifecycle.
+Retries reread current HEAD, worktree, branch, and remote facts. A local commit that already exists is push-only and cannot produce a second commit. Taskless retries create no task record. Orchestration owns stage completion, sealing, and consumption of receipts; direct mode never fabricates them.

package/templates/.agents/skills/commit/reference/commit-orchestration.zh-CN.md

@@ -1,56 +1,21 @@
-# Commit 编排协调
+# Commit Core 边界
 
-本规则仅适用于已解析出 `{task-id}` 的提交。无任务上下文的纯 Git 提交不得读取、创建或完成 commit intent。
+commit、push、结果映射和任务收尾使用同一个 `commit-operation.execute`。入口只负责解析 task scope、显式 agent 和字面 `--orchestrated`，不得从状态文件推断执行来源。
 
-## 执行来源
+## 入口模式
 
-- 只有入口业务操作数中字面出现 `--orchestrated` 时，`{execution-flag}` 才绑定为 `--orchestrated`。
-- 其他调用一律为 standalone；不得从 `orchestration.json`、环境变量或历史活动日志推断来源。
+- `mode=direct`：用户显式调用授权。task-bound direct 可读取 task facts，但不要求 delegation receipt；taskless direct 只在 `TASK_CONTEXT_NOT_FOUND` 时允许，并跳过 task facts、review、task lock、checkpoint 和 task.md 收尾。
+- `mode=orchestrated`：必须绑定明确 task，且 core 在第一个 Git 写入前验证匹配的 activated commit receipt、agent、stage、round、artifact、role 和未消费 capability。缺少任一项都返回 `blocked`，不写 Git。
 
-## 副作用前 begin
+## 共享执行顺序
 
-每次进入 commit 技能先调用 `commit-status`。`recoverable` / `prepared` / `retryable-start` 调用以下无 token 恢复入口，`idle` 调用 `commit-start --agent {standard-agent-token}`；其他状态 fail closed：
+1. 获取 repository/worktree mutation lock；task-bound 额外获取 task lock。
+2. 验证 repository、当前 branch、明确 paths、敏感路径、staged scope、expected HEAD/tree、remote 和 full heads ref。
+3. 完成模式对应的授权校验。
+4. 最多创建一个本地 commit；无修改时只允许 push-only，不创建空 commit。
+5. `main` / `master` 自动 push 返回 `COMMIT_AUTOPUSH_PROTECTED_BRANCH` warning；普通 push 失败返回 `COMMIT_PUSH_FAILED` warning，并保留本地事实。
+6. 返回唯一主结果：`committed`、`no_op`、`committed_with_warnings`、`failed` 或 `blocked`。
 
-```bash
-agent-infra-internal task-orchestration {task-id} commit-recover --agent {standard-agent-token}
-```
+## 重试边界
 
-恢复入口只接受 `--agent`；不得传 token、head 或 `--orchestrated`。从 start/recover 结构化输出读取 `finalization.attempt.attempt` 为 `commit_attempt`，不得手写 attempt。
-
-完成状态、版权、提交信息、review snapshot 和 push 场景的只读准备后，记录 `baseline_head=$(git rev-parse HEAD)`，并在任何 commit、push、任务成功日志或平台成功同步之前调用：
-
-```bash
-commit_intent_result=$(agent-infra-internal task-orchestration {task-id} commit-begin --agent {standard-agent-token} {execution-flag} --baseline-head "$baseline_head" --attempt "$commit_attempt")
-commit_intent_token=$(printf '%s' "$commit_intent_result" | node -e 'let input = ""; process.stdin.on("data", chunk => input += chunk).on("end", () => process.stdout.write(JSON.parse(input).token))')
-```
-
-`commit_intent_token` 只从结构化输出读取一次性 `token`，并仅保存在当前进程内。begin 失败时不得执行后续副作用。
-
-## 副作用 checkpoint
-
-普通 commit 成功后立即记录新 HEAD：
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-checkpoint --token "$commit_intent_token" --kind committed --head "$new_head"
-```
-
-push 成功并完成远端复核后立即记录已验证的 remote/ref/HEAD：
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-checkpoint --token "$commit_intent_token" --kind pushed --head "$pushed_head" --remote "$remote" --ref "$ref"
-```
-
-push-only 路径跳过 committed checkpoint，pushed HEAD 必须等于 begin 时的 baseline HEAD。
-
-## 完成与恢复
-
-committed/pushed checkpoint 完成后、任务同步与 `task-verify commit.completed` 之前调用：
-
-```bash
-agent-infra-internal task-orchestration {task-id} commit-complete --token "$commit_intent_token" --agent {standard-agent-token}
-```
-
-- begin 已创建 intent、但第一个副作用前失败时，先在 HEAD 仍等于 baseline 时调用 `commit-abort --token ... --expected-head ...`；若本轮明确放弃，再调用 `commit-terminate --attempt "$commit_attempt" --agent {standard-agent-token} --code <STABLE_CODE>` 闭合 started。
-- begin 在 intent 创建前失败时可保留 attempt 供下次复用；明确放弃时仅可在 HEAD 未漂移时调用 `commit-terminate`。
-- commit 或 push 发生后失败时不得 abort；保留 intent，并调用 `commit-status` 输出不含 token/digest 的恢复证据。跨会话重跑通过 `commit-recover` 收尾。
-- `commit-complete` 失败时停止。不得重复执行 commit/push，也不得把缺少完整 receipt 生命周期的 run 标记为完成。
+重跑重新读取当前 HEAD、worktree、branch 和 remote 事实。已有本地 commit 时只补 push，不创建第二个 commit；taskless 重跑不创建任何任务记录。orchestrated receipt 的 stage completion、seal 和 consume 由 orchestration core 负责，不由 direct 路径伪造。

package/templates/.agents/skills/commit/reference/pr-summary-sync.en.md

@@ -4,6 +4,6 @@ Run only when `{task-id}` is valid and task.md has a valid `pr_number`.
 
 1. Run `agent-infra-internal platform-pr summary-context {task-id}`.
 2. Generate the plain summary body per `.agents/rules/pr-sync.md` and write it to a temporary file.
-3. Run `agent-infra-internal platform-pr summary-sync {task-id} --agent {standard-agent-token} --body-file {summary-body-file}`.
+3. Run `agent-infra-internal platform-pr summary-sync {task-id} --agent {standard-agent-token} --body-file {summary-body-file} --result no_op`. The commit path only synchronizes an existing PR summary and neither creates nor reuses a PR, so `no_op` explicitly represents the unchanged PR identity.
 
 Failure records a warning but never blocks or rolls back the completed commit. `no-op` maps to `summary skipped (no diff)`.