Merge pull request 'Point the nested agent-native pin at the O2 route contract head' (#55) from feature/fast-slow-o2-i3-agent-native-pin into main

Why: the adoption PR is reviewed and its candidate HEAD passed CI; the card closure is folded into the PR so no separate close PR is needed.
Evidence: CI GATE on b3e7da4a11b976007fa5c2874722b15ce5fd28fe; independent Review REPLAY (cursor-agent-stable --mode ask 全新只读会话（fresh_session=true，session id not-observable）闭合重审 VERDICT: APPROVE（对象 b3e7da4）).
Impact: task card only (moved to .task/archive/).
Refs: https://git-home.u1680832.nyat.app:30319/weichen/Agent-Squad/pulls/54

.gitea/workflows/governance.yml

@@ -0,0 +1,150 @@
+name: governance
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  governance:
+    runs-on: ubuntu-latest
+    env:
+      GOPROXY: https://goproxy.cn,direct
+    steps:
+      - name: Checkout
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SUBMODULE_TOKEN: ${{ secrets.SUBMODULE_TOKEN }}
+        run: |
+          set -euo pipefail
+          # 只物化两个治理 gitlink（Guidelines 与 deps/development-manager），非递归；
+          # 其它 gitlink 不物化、不取回。凭据只以 URL 限定的 extraheader 存在于本进程树内。
+          python3 - <<'PY_CHECKOUT'
+          import os
+          from pathlib import Path
+          import re
+          import subprocess
+          import sys
+          from urllib.parse import urlsplit
+
+          # 服务端基址取运行器注入的 GITHUB_SERVER_URL（平台控制、候选 PR 不可影响）。
+          SERVER = os.environ.get("GITHUB_SERVER_URL", "").rstrip("/")
+          parsed_server = urlsplit(SERVER)
+          if parsed_server.scheme not in {"http", "https"} or not parsed_server.netloc:
+              sys.exit("Checkout server must be the platform-injected http(s) URL")
+          SSH = "ssh://git@git-ssh.u1680832.nyat.app:31411/weichen/"
+          # 审查过的白名单，独立于候选 .gitmodules：仅列出两个治理 gitlink。
+          REPOSITORIES = {
+              "deps/development-guidelines": "Development-Guidelines",
+              "deps/development-manager": "Development-Manager",
+          }
+          TARGET = "weichen/Agent-Squad"
+          root_token = os.environ.pop("TOKEN", "")
+          component_token = os.environ.pop("SUBMODULE_TOKEN", "")
+          if not root_token or not component_token:
+              sys.exit("Checkout requires TOKEN and SUBMODULE_TOKEN")
+          if os.environ.get("GITHUB_REPOSITORY") != TARGET:
+              sys.exit("Checkout repository is outside the reviewed allowlist")
+          sha = os.environ.get("GITHUB_SHA", "")
+          if not re.fullmatch(r"[0-9a-fA-F]{40}", sha):
+              sys.exit("Checkout requires a fixed commit SHA")
+
+          # 丢弃继承的 Git 追踪/配置/SSH 钩子；凭据只存在于单个 Git 进程树的精确 URL 头中。
+          clean_env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+          clean_env.update(GIT_CONFIG_NOSYSTEM="1", GIT_CONFIG_SYSTEM="/dev/null",
+                           GIT_CONFIG_GLOBAL="/dev/null", GIT_TERMINAL_PROMPT="0")
+          config = {
+              "core.hooksPath": "/dev/null", "core.fsmonitor": "false",
+              "init.templateDir": "", "credential.helper": "",
+              "fetch.recurseSubmodules": "false", "submodule.recurse": "false",
+              "http.followRedirects": "false", "protocol.allow": "never",
+              "protocol." + urlsplit(SERVER).scheme + ".allow": "always",
+          }
+
+
+          def git(repo, *args, extra=None):
+              values = config | (extra or {})
+              env = clean_env | {"GIT_CONFIG_COUNT": str(len(values))}
+              for index, (key, value) in enumerate(values.items()):
+                  env[f"GIT_CONFIG_KEY_{index}"] = key
+                  env[f"GIT_CONFIG_VALUE_{index}"] = value
+              return subprocess.run(["git", "-C", str(repo), *args], env=env,
+                                    check=True, stdout=subprocess.PIPE).stdout
+
+
+          def materialize_governance(root):
+              # -r 列出任意深度的 gitlink，但不进入 submodule 内部；其它 gitlink 只记录、从不取回。
+              links = {}
+              for entry in git(root, "ls-tree", "-rz", "HEAD").split(b"\0"):
+                  if not entry:
+                      continue
+                  metadata, path = entry.split(b"\t", 1)
+                  mode, kind, commit = metadata.decode().split()
+                  if mode == "160000":
+                      links[path.decode()] = commit
+              for name in REPOSITORIES:
+                  if name not in links:
+                      raise ValueError("Governance gitlink is missing from the fixed commit")
+              raw = git(root, "config", "--no-includes", "--blob", "HEAD:.gitmodules", "--null", "--list")
+              entries = {}
+              for item in raw.split(b"\0"):
+                  if not item:
+                      continue
+                  key, value = item.decode().split("\n", 1)
+                  match = re.fullmatch(r"submodule\.(.+)\.(path|url)", key)
+                  if not match:
+                      continue
+                  name, field = match.groups()
+                  if name not in REPOSITORIES:
+                      continue
+                  if field in entries.setdefault(name, {}):
+                      raise ValueError("Duplicate candidate .gitmodules setting")
+                  entries[name][field] = value
+              # 先整体校验两个治理条目，再进行任何带凭据的取回。
+              for name, repository in REPOSITORIES.items():
+                  fields = entries.get(name, {})
+                  if fields.get("path") != name:
+                      raise ValueError("Governance submodule path is outside the reviewed allowlist")
+                  trusted_url = f"{SERVER}/weichen/{repository}.git"
+                  if fields.get("url") not in {SSH + repository + ".git", trusted_url}:
+                      raise ValueError("Governance submodule URL is outside the reviewed allowlist")
+              for name, repository in REPOSITORIES.items():
+                  url = f"{SERVER}/weichen/{repository}.git"
+                  # 仅持久化审查过的公开 URL，使 Git 在进程级配置消失后仍识别该 submodule。
+                  git(root, "config", f"submodule.{name}.url", url)
+                  git(root, "submodule", "update", "--init", "--checkout", "--", name,
+                      extra={f"submodule.{name}.url": url,
+                             f"submodule.{name}.update": "checkout",
+                             f"http.{url}.extraheader": "AUTHORIZATION: token " + component_token})
+                  child = root / name
+                  if git(child, "rev-parse", "HEAD").decode().strip() != links[name]:
+                      raise ValueError("Materialized governance gitlink does not match the fixed SHA")
+
+
+          try:
+              root = Path.cwd()
+              # 必须是干净的临时工作区；不复用既有 Git 状态。
+              if (root / ".git").exists():
+                  raise ValueError("Checkout requires a fresh workspace")
+              git(root, "init", "-q")
+              url = f"{SERVER}/{TARGET}.git"
+              git(root, "remote", "add", "origin", url)
+              git(root, "fetch", "--depth=1", "origin", sha,
+                  extra={f"http.{url}.extraheader": "AUTHORIZATION: token " + root_token})
+              git(root, "checkout", "-q", "--detach", "FETCH_HEAD")
+              materialize_governance(root)
+          except (ValueError, OSError, subprocess.CalledProcessError) as error:
+              sys.exit(f"Checkout refused: {error}")
+          print("Checkout complete; credentials were not persisted in Git configuration")
+          PY_CHECKOUT
+          unset TOKEN SUBMODULE_TOKEN
+      - name: Install Go 1.27.1
+        run: |
+          set -euo pipefail
+          curl -fsSL -o "$RUNNER_TEMP/go.tgz" https://mirrors.aliyun.com/golang/go1.27.1.linux-amd64.tar.gz
+          tar -C /usr/local -xzf "$RUNNER_TEMP/go.tgz"
+          ln -sfn /usr/local/go/bin/go /usr/local/bin/go
+          ln -sfn /usr/local/go/bin/gofmt /usr/local/bin/gofmt
+      - name: Validate agent execution configuration
+        run: scripts/agent-exec validate --repo .
+      - name: Governance check
+        run: scripts/dm governance check --repo .

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "deps/agent-intent"]
 	path = deps/agent-intent
 	url = ssh://git@git-ssh.u1680832.nyat.app:31411/weichen/Agent-Intent.git
+[submodule "deps/development-manager"]
+	path = deps/development-manager
+	url = ssh://git@git-ssh.u1680832.nyat.app:31411/weichen/Development-Manager.git

.task/archive/feature-governance-adoption.md

@@ -0,0 +1,58 @@
+# Agent-Squad 采纳 development-governance-v2 治理套件 任务卡
+
+任务主记录：[Agent-Squad PR #54](https://git-home.u1680832.nyat.app:30319/weichen/Agent-Squad/pulls/54)（本文件随 PR 描述维护）。
+状态：已完成（闭合随本 PR 合入；合入以平台记录为准）；owner：weichen。
+
+## 基线与授权
+
+- 权威仓：weichen/Agent-Squad；root_target：main；immediate_target：main
+- branch_kind：initiative；initiative_id：governance-adoption-Agent-Squad
+- R0（initial_main_sha）：490b0b2dfa1567cb16ff7a7230fd78e52bc2938e；工作区：/home/weichen/projects/Agent-Squad-wt-feature-governance-adoption（worktree）；分支：feature/governance-adoption
+- 父任务信息（仅子任务填写）：无
+- accepting_requirements：false（单仓采纳 initiative，范围固定为下列十步，不接收新需求）
+- 需求分流：verdict=NEW；selected_initiative=无；候选=无；理由=development-governance-v2 Phase 6 每个正式仓库独立 initiative；triage 收据=无（本仓采纳前尚无 triage 入口）
+- 授权与交付终点：owner 已授权 development-governance-v2 全部实施（Agent-System-Dev 主记录 docs/superpowers/plans/2026-10-16-development-governance-v2-master.md）；终点为本 PR 合入 main 且采纳状态 active。分支保护与 tag 由用户执行。
+- 实施执行：agent-per-unit（配置：AGENT-EXECUTION.md；外部 Agent 一单元一新进程/会话/工作区）
+
+## 目标与非目标
+
+目标（Phase 6 十步）：固定 Guidelines SHA（deps/development-guidelines @ 2688fd2be6a52c0bf110e7e6366b6f291ab5e4eb）；增加 AGENT-EXECUTION.md；增加共享执行器薄入口（deps/development-manager @ bd3a7de57a3a9e1a4495b94c5fa5c08d71e7be8c + scripts/dm、scripts/agent-exec、scripts/task）；四条路由（implementation/repair/test/review）；任务卡模板与分支元数据；CI 中启用 schema 校验（.gitea/workflows/governance.yml：agent-exec validate + governance check）；一次正例运行；负例（缺配置、坏收据、越界路径、未知副作用）；独立 Review + CI；采纳状态 active。
+
+非目标：不改业务代码与既有测试；不改分支保护（由用户执行）；不发布 tag。
+
+范围说明（Review 阻塞项 2）：`scripts/submodule-consistency.sh` 要求 deps/agent-native、deps/agent-intent 内嵌的 Guidelines/错误码/日志 gitlink 与本仓一致；本 PR 把 Guidelines 固定到 2688fd2 后，按最小修复把这两个 gitlink 升到各自已合入治理采纳的 main（Agent-Native 14d4869、Agent-Intent 651a2e1；两者相对原固定版本只增治理文件、不改 Go 代码），其余 gitlink 不动。核对见证据 `scripts/submodule-consistency.sh`。
+
+引导说明：AGENT-EXECUTION.md 由 host 以固定版本治理套件（dm-server governance init @ bd3a7de57a3a9e1a4495b94c5fa5c08d71e7be8c）生成并作为引导配置提交（执行器运行前必须存在有效配置；沿用 DM 采纳先例）；其余文件由实施单元生成。
+
+## Agent 实施收据
+
+| 单元 ID | 预期范围 | 角色 | 候选顺序 | attempt | CLI/模型 | 终态 | transport | fallback | 源码外收据路径 |
+|---|---|---|---|---|---|---|---|---|---|
+| governance-adoption-Agent-Squad-r1 | 13 个允许路径（治理文件 + 两个 gitlink） |  | implementation | cursor→antigravity→pi | run 71696608（dm-server pinned，attempts=1） | cursor / not-observable | failed-unknown | 无（apply 快进） | 否 | /tmp/gov-receipt-Agent-Squad-r1.json |
+| 对账（r1） | 规范 worktree 仍为 2a2a1fd 且干净；无 transport ref | — | — | — | — | — | 已对账；全新运行 r2（单元包追加禁止固定共享 /tmp 路径约束） | — | — | — |
+| governance-adoption-Agent-Squad-r2 | 13 个允许路径（治理文件 + 两个 gitlink） | b83905a8 | implementation | cursor→antigravity→pi | run 145e30ce（dm-server 42e675f，attempts=1） | cursor / not-observable | success | 468878f62ede（apply 快进） | 否 | /tmp/gov-receipt-Agent-Squad-r2.json |
+| （无效启动 repair-r0） | — | repair | — | 无 attempt | — | invalid-config（单元包尚未写出即启动，执行器读取失败；无 attempt、无副作用，worktree 仍为 e29284e 且干净） | 无 | 否 | /tmp/gov-receipt-Agent-Squad-repair-r0-invalid-unit-path.json |
+| governance-adoption-Agent-Squad-repair-r1 | policy/guidelines-adoption.md、PROJECT.md、deps/agent-native、deps/agent-intent | repair | cursor→antigravity→pi | run fadb9c92（attempts=1） | cursor / not-observable | success | d0f9081f47eb（apply 快进） | 否 | /tmp/gov-receipt-Agent-Squad-repair-r1.json |
+
+## 同步记录
+
+| 节点 | sync_base_sha | tested_head_sha | checked_at | 结果 |
+|---|---|---|---|---|
+| 启动 | 490b0b2dfa1567cb16ff7a7230fd78e52bc2938e | 490b0b2dfa1567cb16ff7a7230fd78e52bc2938e | 2026-10-17T07:17:41Z | 一致 |
+
+## 结果与验证（完成后填写）
+
+- 结果：治理套件已采纳——Guidelines 与 Development-Manager gitlink 固定、AGENT-EXECUTION.md 四条路由、共享执行器薄入口、pre-commit admit、governance CI；采纳状态 active（随合入生效）。
+- 验证：见下表（命令输出由 /tmp/gov-neg/ev.sh 写入 .task/evidence/governance-adoption/，SELF 除非另注）。
+- 影响与剩余项：不改业务代码；本地启用钩子需由人执行 `git config core.hooksPath scripts/hooks`；将 governance 检查设为分支保护必需项属用户双钥匙事项（命令见 Agent-System-Dev 治理主记录）。
+
+| 时间(UTC) | 命令 | 被测 HEAD | exit | 来源 | 摘要/位置 |
+|---|---|---|---|---|---|
+| 20261017T080150Z | `scripts/dm governance check --repo .` | 468878f62ede | 0 | SELF | ok fixtures；[输出](../evidence/governance-adoption/00-20261017T080150Z.log) sha256:b07d207012a2fd6d |
+| 20261017T080150Z | `scripts/agent-exec validate --repo .` | 468878f62ede | 0 | SELF | validate: ok；[输出](../evidence/governance-adoption/01-20261017T080150Z.log) sha256:b3a91246221bb5f8 |
+| 20261017T080150Z | `python3 /tmp/gov-neg/adopt_cases.py .` | 468878f62ede | 0 | SELF | [verdict] ALL PASS cases=5；[输出](../evidence/governance-adoption/02-20261017T080150Z.log) sha256:109906d5e57fe039 |
+| 20261017T094306Z | `scripts/dm governance check --repo .` | d0f9081f47eb | 0 | SELF | ok fixtures；[输出](../evidence/governance-adoption/03-20261017T094306Z.log) sha256:b904686133da5f80 |
+| 20261017T094306Z | `scripts/agent-exec validate --repo .` | d0f9081f47eb | 0 | SELF | validate: ok；[输出](../evidence/governance-adoption/04-20261017T094306Z.log) sha256:19dc223efda318d6 |
+| 20261017T094308Z | `scripts/submodule-consistency.sh` | 05b509827274 | 0 | SELF | ok deps/agent-intent 651a2e1e03c4326888ef9f742ce592140ae30ab8；[输出](../evidence/governance-adoption/05-20261017T094308Z.log) sha256:bc528fe029ed41d2 |
+| — | 候选 HEAD CI | b3e7da4a11b9 | 0 | GATE | success ci / docker-checkout-hostgateway (pull_request)=success（/weichen/Agent-Squad/actions/runs/3672/jobs/5787）；governance / governance (pull_request)=success（/weichen/Agent-Squad/actions/runs/3673/jobs/5788）；ci / vet-and-test (pull_request)=success（/weichen/Agent-Squad/actions/runs/3672/jobs/5786） |
+| — | 独立 Review | b3e7da4a11b9 | 0 | REPLAY | cursor-agent-stable --mode ask 全新只读会话（fresh_session=true，session id not-observable）闭合重审 VERDICT: APPROVE（对象 b3e7da4） |

.task/evidence/governance-adoption/00-20261017T080150Z.log

@@ -0,0 +1,19 @@
+command: scripts/dm governance check --repo . 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: 468878f62eded8347d18a1d6c1b7c5f7e24a9c4c
+exit: 0
+utc: 20261017T080150Z
+---
+ok gitlink deps/development-guidelines
+ok gitlink deps/development-manager
+ok agent-execution
+ok file AGENTS.md
+ok file PROJECT.md
+ok file policy/guidelines-adoption.md
+ok file .task/templates/task-card.md
+ok executable scripts/agent-exec
+ok executable scripts/hooks/pre-commit
+ok executable scripts/dm
+ok executable scripts/task
+ok adoption status
+ok fixtures

.task/evidence/governance-adoption/01-20261017T080150Z.log

@@ -0,0 +1,7 @@
+command: scripts/agent-exec validate --repo . 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: 468878f62eded8347d18a1d6c1b7c5f7e24a9c4c
+exit: 0
+utc: 20261017T080150Z
+---
+validate: ok

.task/evidence/governance-adoption/02-20261017T080150Z.log

@@ -0,0 +1,13 @@
+command: python3 /tmp/gov-neg/adopt_cases.py . 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: 468878f62eded8347d18a1d6c1b7c5f7e24a9c4c
+exit: 0
+utc: 20261017T080150Z
+---
+[object] Agent-Squad-wt-feature-governance-adoption HEAD=468878f62eded8347d18a1d6c1b7c5f7e24a9c4c
+PASS positive-run-apply: run exit=0 terminal=success apply exit=0 head=312d80d409a1
+PASS missing-config: run exit=2 terminal=invalid-config validate exit=2
+PASS bad-receipt: apply exit=4 head_unchanged=True msg=apply: no local integrity record: changed paths do not match the transport diff
+PASS out-of-scope-path: run exit=5 terminal=scope-expansion transport=False
+PASS unknown-side-effect: run exit=4 terminal=failed-unknown transport=False
+[verdict] ALL PASS cases=5

.task/evidence/governance-adoption/03-20261017T094306Z.log

@@ -0,0 +1,19 @@
+command: scripts/dm governance check --repo . 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: d0f9081f47eb59565323f731cb8085e5891dd7ba
+exit: 0
+utc: 20261017T094306Z
+---
+ok gitlink deps/development-guidelines
+ok gitlink deps/development-manager
+ok agent-execution
+ok file AGENTS.md
+ok file PROJECT.md
+ok file policy/guidelines-adoption.md
+ok file .task/templates/task-card.md
+ok executable scripts/agent-exec
+ok executable scripts/hooks/pre-commit
+ok executable scripts/dm
+ok executable scripts/task
+ok adoption status
+ok fixtures

.task/evidence/governance-adoption/04-20261017T094306Z.log

@@ -0,0 +1,7 @@
+command: scripts/agent-exec validate --repo . 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: d0f9081f47eb59565323f731cb8085e5891dd7ba
+exit: 0
+utc: 20261017T094306Z
+---
+validate: ok

.task/evidence/governance-adoption/05-20261017T094308Z.log

@@ -0,0 +1,14 @@
+command: scripts/submodule-consistency.sh 
+cwd: /home/weichen/projects/Agent-Squad-wt-feature-governance-adoption
+head: 05b5098272741987767efa2e78b8fe01aa84b6e5
+exit: 0
+utc: 20261017T094308Z
+---
+ok development-guidelines@deps/agent-native 2688fd2be6a52c0bf110e7e6366b6f291ab5e4eb
+ok error-code-system@deps/agent-native a3ee67bba269e1276c14e22c026171ecf2cf6190
+ok logging-system@deps/agent-native 49b5d8be604d05e4246dffa0d10fa1c2b7ad45d7
+ok development-guidelines@deps/agent-intent 2688fd2be6a52c0bf110e7e6366b6f291ab5e4eb
+ok error-code-system@deps/agent-intent a3ee67bba269e1276c14e22c026171ecf2cf6190
+ok logging-system@deps/agent-intent 49b5d8be604d05e4246dffa0d10fa1c2b7ad45d7
+ok deps/agent-native 14d48697a69ddba9ebc67ba7daa588f1b082d096
+ok deps/agent-intent 651a2e1e03c4326888ef9f742ce592140ae30ab8

.task/templates/task-card.md

@@ -0,0 +1,66 @@
+# <任务标题> 任务卡
+
+任务主记录：<Issue/PR 链接，或注明"本文件随 PR 描述维护">。
+状态：<进行中 / 待审核 / 已合入 / 已放弃>；owner：<填写>。
+
+## 基线与授权
+
+- 权威仓：<仓 URL 或逻辑 ID>；root_target：main；immediate_target：<main 或 feature/initiative>
+- branch_kind：<initiative | child | standalone>；initiative_id：<稳定 ID，普通任务为空>
+- R0（initial_main_sha）：<完整 SHA>；工作区：<路径>（worktree / clone）；分支：<feature|fix|hotfix/...>
+- 父任务信息（仅子任务填写）：parent_branch=<父分支>；parent_head_sha=<SHA>；parent_pr=<父 PR>
+- accepting_requirements：<true | false>（仅 initiative 可为 true；冻结后为 false）
+- 需求分流：verdict=<JOIN | NEW>；selected_initiative=<分支或无>；候选=<分支@HEAD 列表或无>；理由=<不适配/适配依据>；triage 收据=<源码外路径与摘要>
+- 授权与交付终点：<本次允许的动作与终点；未授权事项写明>
+- 实施执行：agent-per-unit（配置：AGENT-EXECUTION.md；外部 Agent 一单元一新进程/会话/工作区）
+
+## 目标与非目标
+
+<预期结果、受影响入口/模块/契约；明确不做什么。>
+
+## Agent 实施收据
+
+按根目录 AGENT-EXECUTION.md 路由；外部 Agent 一单元一新进程/会话/隔离工作区。实施、修复与测试必须通过登记的候选执行；未配置或候选安全耗尽停在 unavailable/blocked，禁止 host 隐式代写。
+
+| 单元 ID | 预期范围 | 角色 | 候选顺序 | attempt | CLI/模型 | 终态 | transport | fallback | 源码外收据路径 |
+|---|---|---|---|---|---|---|---|---|---|
+| 待定义 | — | NOT_RUN | NOT_RUN | NOT_RUN | NOT_RUN | NOT_RUN | NOT_RUN | NOT_RUN | — |
+
+## 复用材料（task-start 自动检索结果摘录）
+
+- 相关近期提交：<git log -- <paths> 命中；无则写无>。
+- 相关经验条目：<检索命中；无则写无>。
+
+## 同步记录
+
+| 节点 | sync_base_sha | tested_head_sha | checked_at | 结果 |
+|---|---|---|---|---|
+| 启动 | <R0> | <HEAD> | <日期时间> | <一致/已同步> |
+| 验收前 | <填写> | <填写> | <填写> | <填写> |
+
+字段没有发生的写"无"，不省略。本卡与 PR 描述同源：开 PR 时将"目标与非目标、结果与验证、影响与剩余项"复制进 PR 描述，不另写第二份。
+
+## 交付调度（有多个就绪任务时）
+
+- 调度记录 / entry_id / 当前 attempt_id：<平台或调度服务链接及标识；未入队写无>。
+- 入队源 HEAD / owner / 依赖：<完整 SHA、身份、依赖或无>。
+- 固定候选引用：<调度尝试中的 base/head、组件与配置；未固定写无>。
+- 窗口、最终 CI、Review 与真实合入结果：<引用调度记录及原始证据，不复制全队列>。
+
+定义见 [合入调度与 CI 分配](../standards/merge-queue.md)。本段在候选固定前整理；固定后先使用源码之外的记录保存运行结果，再按项目闭合流程回填。
+
+## 结果与验证（完成后填写）
+
+- 结果：<交付了什么；未发生写无>。
+- 验证：<结论性摘要：PASS/FAIL/SKIP/NOT_RUN 逐项；逐条证据见下表，来源标注与写入规则见 [按影响选择验证与证据](../standards/verification.md)>。
+- 影响与剩余项：<影响面、遗留风险、后续任务>。
+
+| 时间(UTC) | 命令 | 被测 HEAD | exit | 来源 | 摘要/位置 |
+|---|---|---|---|---|---|
+| <时间> | <命令；由项目 evidence 工具写入，无工具时附命令+对象 SHA+输出 digest 并标 SELF> | <HEAD> | <exit> | GATE/REPLAY/SELF | <摘要/位置> |
+
+## 回收（task-finish）
+
+- 合入核对：<分支已包含于目标分支的核对输出>。
+- 未跟踪/ignored 文件处置：<归档/可再生/存疑 逐项；无则写无>。
+- 回收动作：<worktree remove、分支删除、prune；放弃路径注明原因>。

AGENT-EXECUTION.md

@@ -0,0 +1,67 @@
+# Project Agent Execution Configuration
+# 项目工程 Agent 执行路由配置
+
+适用范围：定义本项目中由 AI / Agent 主导的代码实施、修复、测试与审阅所调用的 Agent CLI 路由。
+解析器识别正文中唯一一个 ```agent-execution 代码块。正文外的说明文字可根据项目需要调整。
+
+通用硬规则见 Development-Guidelines 的 [Agent 执行与协作契约](deps/development-guidelines/standards/agent-execution.md)。
+本配置为项目本地路由权威，声明具体的候选 profile、尝试次数上限、超时、集成入口与豁免路径；
+代码块须通过 `deps/development-guidelines/templates/schemas/agent-execution.schema.json` 校验后才能登记为 active。
+`fallback_to_host` 只能为 `never`；旧值 `all-unavailable` 仅供迁移工具读取，不能通过准入。
+下例的 CLI 名称、命令与路径均为占位，按项目实际执行器替换。
+
+```agent-execution
+schema: agent-execution/v1
+
+execution:
+  fresh_process_per_unit: true
+  permission: run-everything
+  fallback_to_host: never
+  max_parallel: 3
+  timeout_seconds: 7200
+  idle_timeout_seconds: 600
+  summary_bytes: 16384
+  raw_output_bytes: 10485760
+  max_attempts_per_profile: 3
+  emergency_profile: codex
+
+roles:
+  implementation: [cursor, antigravity, pi]
+  repair: [cursor, antigravity, pi]
+  test: [pi, antigravity, cursor]
+  review: [pi, antigravity, cursor, codex]
+
+profiles:
+  cursor:
+    adapter: cursor
+    executable: "cursor-agent-stable"
+    model: auto
+    enabled: true
+
+  antigravity:
+    adapter: antigravity
+    executable: agy
+    model: auto
+    enabled: true
+
+  pi:
+    adapter: pi
+    executable: pi
+    model: auto
+    enabled: true
+
+  codex:
+    adapter: codex
+    executable: codex
+    model: auto
+    enabled: true
+
+integration:
+  exempt_paths: [".task/**", "docs/superpowers/specs/**", "docs/superpowers/plans/**"]
+  transport:
+    command: "scripts/agent-exec apply"
+  admission:
+    command: "scripts/agent-exec admit"
+  cleanup:
+    command: "scripts/agent-exec cleanup"
+```

AGENTS.md

@@ -34,3 +34,21 @@
 - **SSH key**：`~/.ssh/home_gitea`（ED25519，公钥指纹
   `SHA256:GYXaOXIMeloQ1fKSfdJ/ndgPQzs/Ix7Hk62ekfkfQ20`，Gitea 侧密钥名 GMKtec）；
   `~/.ssh/config` 已有 `git-ssh.u1680832.nyat.app` 主机条目，克隆/推送直接可用。
+
+## Agent 执行与新项目准入（强制）
+
+1. 缺 Guidelines 固定版本（`deps/development-guidelines` gitlink 未就绪或 HEAD 不符）时，Agent 只能只读分析，不得实施。
+2. 缺有效 `AGENT-EXECUTION.md`（`scripts/dm governance check` 未通过）时禁止 AI 实施。
+3. 缺共享执行器（`scripts/agent-exec` 或 `deps/development-manager` 不可用）时，状态为 `blocked/unavailable`，不得改由 host 替代。
+4. 不允许 host 代写实施单元；实施、修复与测试必须经 `AGENT-EXECUTION.md` 登记的候选执行。
+5. 人类直接开发按其自身授权与项目规则进行，不受本条款约束。
+6. 分支保护与规范 tag 由用户负责设置与维护，Agent 不得代为设置。
+
+入口：
+
+- 需求分流：`scripts/task triage discover|decide|verify`
+- 任务启动：`scripts/task start …`
+- PR 检查：`scripts/task pr-check …`
+- Agent 执行：`scripts/agent-exec run|apply|admit|validate`
+
+AI 实施单元只经 `scripts/agent-exec run` 按 AGENT-EXECUTION.md 运行，并经 `scripts/agent-exec apply` 集成。

PROJECT.md

@@ -12,8 +12,8 @@
 - 提交/审核/合并/发布身份与权限：仓库所有者 weichen。
 - 任务唯一来源：Gitea `weichen/Agent-Squad` 的 Issue 与 Pull Request。
 - 规范性文档目录：`policy/`。
-- 过程文档仓/目录：`docs/records/`（项目内豁免，见采纳记录）。
+- 过程文档仓/目录：任务卡与交付证据在 `.task/`（模板 `.task/templates/task-card.md`）；其他过程记录在 `docs/records/`（项目内豁免，见采纳记录）。
-- 交接记录位置：随任务主记录；需要落盘的交接放入 `docs/records/`。
+- 交接记录位置：随任务主记录；需要落盘的任务交接与交付证据放入 `.task/`，其他落盘交接放入 `docs/records/`。
 - 凭证查找入口及所需字段：LLM 使用环境变量 `AGENT_SQUAD_LLM_BASE_URL`、`AGENT_SQUAD_LLM_API_KEY`、`AGENT_SQUAD_LLM_MODEL`。日志采集 token 使用日志库自己的配置。文档与仓库不记录这些值。
 
 ## 依赖组合
@@ -45,6 +45,7 @@ git clone --recurse-submodules ssh://git@git-ssh.u1680832.nyat.app:31411/weichen
 | 模块/接口 | 仓库根：`GOWORK=off go vet ./... && GOWORK=off go test -count=1 ./...` | 需要已初始化的 Agent-Native 子模块；默认 stub，不调用真实模型 |
 | 数据/权限/恢复 | conformance 与 store 测试覆盖运行落盘、HITL 恢复 | 无共享数据库 |
 | UI/执行后端 | `GOWORK=off go test -count=1 ./server/... ./conformance/...` | 不覆盖浏览器；SSE 由测试客户端验证 |
+| 治理与 Agent 执行配置 | 仓库根：`scripts/agent-exec validate --repo .` 与 `scripts/dm governance check --repo .` | 需 `deps/development-manager` 已按 gitlink 检出（首次 `dm` 调用会构建 dm-server）；只核验 AGENT-EXECUTION.md 与治理文件，不证明实施单元正确 |
 
 ## 环境与数据
 

adapters/a2a/card.go

@@ -0,0 +1,179 @@
+// Package a2a 把小队接入 A2A（Agent2Agent）1.0 互通面（Q3 WP4）：
+//   - 发布侧：BuildCard 从角色注册表与蓝图注册表渲染 Agent Card（描述本
+//     团队能力），CardHandler 以 JSON 服务（挂载在
+//     /.well-known/agent-card.json）；
+//   - 消费侧：FetchCard 发现远端 Agent Card（fail-closed 校验必备字段），
+//     Executor 实现 squad.Executor——message/send 发起任务，tasks/get 轮询
+//     A2A 任务状态机（submitted/working/input-required → completed/failed/
+//     canceled），终态映射 ExecResult：completed 的 artifacts（TextPart/
+//     FilePart）落成 patches/目标文件；failed/canceled/input-required 一律
+//     Success=false（跨进程挂起不在本适配面内，fail-closed 交引擎重试/降级
+//     语义处理）。
+//
+// 传输为 JSON-RPC 2.0 over HTTP（A2A 1.0 形态）；不引入协议之外的依赖。
+package a2a
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"agent-squad/squad"
+)
+
+// ProtocolVersion 对齐的 A2A 协议版本。
+const ProtocolVersion = "1.0"
+
+// WellKnownPath 是 Agent Card 的发现路径（A2A 1.0）。
+const WellKnownPath = "/.well-known/agent-card.json"
+
+// AgentCard 是 A2A 1.0 Agent Card（发布与消费共用形态）。
+type AgentCard struct {
+	ProtocolVersion string `json:"protocolVersion"`
+	Name            string `json:"name"`
+	Description     string `json:"description,omitempty"`
+	// URL 是 JSON-RPC 服务端点（消费侧据此发 message/send）。
+	URL         string   `json:"url"`
+	Version     string   `json:"version"`
+	Capabilities CardCapabilities `json:"capabilities"`
+	DefaultInputModes  []string `json:"defaultInputModes,omitempty"`
+	DefaultOutputModes []string `json:"defaultOutputModes,omitempty"`
+	Skills      []AgentSkill `json:"skills,omitempty"`
+}
+
+// CardCapabilities 能力声明（本适配面：非流式、无推送、无状态历史）。
+type CardCapabilities struct {
+	Streaming              bool `json:"streaming"`
+	PushNotifications      bool `json:"pushNotifications"`
+	StateTransitionHistory bool `json:"stateTransitionHistory"`
+}
+
+// AgentSkill 是一项可被远端调用的能力。
+type AgentSkill struct {
+	ID          string   `json:"id"`
+	Name        string   `json:"name"`
+	Description string   `json:"description,omitempty"`
+	Tags        []string `json:"tags,omitempty"`
+	Examples    []string `json:"examples,omitempty"`
+}
+
+// CardOptions 覆盖 BuildCard 的身份字段（空则用缺省）。
+type CardOptions struct {
+	Name        string
+	Description string
+	// URL JSON-RPC 端点（必填：远端没有端点就无法调用本团队）。
+	URL string
+	// Version 卡片版本（空 = "1.0.0"）。
+	Version string
+	// Skills 显式能力清单；空 = 从注册表派生。
+	Skills []AgentSkill
+}
+
+// BuildCard 从角色注册表与蓝图注册表渲染 Agent Card（描述本团队能力）。
+// 角色 → 技能（关键词作 tags）；蓝图 → 技能（match 词作 examples）。
+func BuildCard(reg *squad.RoleRegistry, bps *squad.BlueprintRegistry, opts CardOptions) (AgentCard, error) {
+	if strings.TrimSpace(opts.URL) == "" {
+		return AgentCard{}, fmt.Errorf("a2a: Agent Card 需要 JSON-RPC 端点 URL")
+	}
+	card := AgentCard{
+		ProtocolVersion: ProtocolVersion,
+		Name:            orDefault(opts.Name, "agent-squad"),
+		Description:     opts.Description,
+		URL:             opts.URL,
+		Version:         orDefault(opts.Version, "1.0.0"),
+		DefaultInputModes:  []string{"text/plain"},
+		DefaultOutputModes: []string{"text/plain"},
+		Skills:          append([]AgentSkill(nil), opts.Skills...),
+	}
+	if len(card.Skills) == 0 {
+		if reg != nil {
+			for _, role := range reg.List() {
+				desc := firstLine(role.Instructions)
+				if desc == "" {
+					desc = role.Name
+				}
+				card.Skills = append(card.Skills, AgentSkill{
+					ID: role.Role, Name: orDefault(role.Name, role.Role),
+					Description: desc, Tags: append([]string(nil), role.Keywords...),
+				})
+			}
+		}
+		if bps != nil {
+			for _, bp := range bps.List() {
+				card.Skills = append(card.Skills, AgentSkill{
+					ID: bp.Key, Name: orDefault(bp.Title, bp.Key),
+					Description: bp.Description, Examples: append([]string(nil), bp.Match...),
+				})
+			}
+		}
+	}
+	return card, nil
+}
+
+// CardHandler 以 JSON 服务 Agent Card（调用方挂载到 WellKnownPath）。
+func CardHandler(card AgentCard) http.Handler {
+	body, _ := json.Marshal(card)
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write(body)
+	})
+}
+
+// FetchCard 发现并校验远端 Agent Card（fail-closed：必备字段缺失即拒）。
+func FetchCard(client *http.Client, wellKnownURL string) (AgentCard, error) {
+	if client == nil {
+		client = http.DefaultClient
+	}
+	resp, err := client.Get(wellKnownURL)
+	if err != nil {
+		return AgentCard{}, fmt.Errorf("a2a: 获取 Agent Card: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return AgentCard{}, fmt.Errorf("a2a: Agent Card 端点返回 %d", resp.StatusCode)
+	}
+	var card AgentCard
+	if err := json.NewDecoder(resp.Body).Decode(&card); err != nil {
+		return AgentCard{}, fmt.Errorf("a2a: Agent Card 解析失败: %w", err)
+	}
+	if err := validateCard(card); err != nil {
+		return AgentCard{}, err
+	}
+	return card, nil
+}
+
+// validateCard 消费侧最小校验（A2A 1.0 必备字段）。
+func validateCard(card AgentCard) error {
+	if card.ProtocolVersion == "" {
+		return fmt.Errorf("a2a: Agent Card 缺 protocolVersion")
+	}
+	if strings.TrimSpace(card.Name) == "" {
+		return fmt.Errorf("a2a: Agent Card 缺 name")
+	}
+	if strings.TrimSpace(card.URL) == "" {
+		return fmt.Errorf("a2a: Agent Card 缺 url")
+	}
+	if strings.TrimSpace(card.Version) == "" {
+		return fmt.Errorf("a2a: Agent Card 缺 version")
+	}
+	return nil
+}
+
+func orDefault(v, def string) string {
+	if strings.TrimSpace(v) != "" {
+		return v
+	}
+	return def
+}
+
+func firstLine(s string) string {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexByte(s, '\n'); i >= 0 {
+		s = s[:i]
+	}
+	if len(s) > 120 {
+		s = s[:120] + "…"
+	}
+	return s
+}

adapters/a2a/conformance_test.go

@@ -0,0 +1,345 @@
+package a2a
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"agent-squad/squad"
+)
+
+// conformance_test.go — Q3 WP4 验收：双向 conformance（本地假 A2A 服务端）。
+// 发布侧：BuildCard + CardHandler 在 well-known 路径服务合法 Agent Card；
+// 消费侧：FetchCard 发现校验 + Executor 走完任务状态机
+// （submitted→working→completed / failed / input-required），终态对齐
+// squad.ExecResult。
+
+// fakeA2AServer 最小 A2A 1.0 服务端：well-known 卡片 + JSON-RPC
+// （message/send 建任务；tasks/get 按脚本推进状态）。
+type fakeA2AServer struct {
+	mu     sync.Mutex
+	card   AgentCard
+	tasks  map[string]*Task
+	plan   []string // 每次 tasks/get 推进到的状态序列（走完停在末态）
+	calls  map[string]int
+	artifacts []Artifact
+	statusMsg string
+}
+
+func newFakeServer(t *testing.T, card AgentCard, plan []string, artifacts []Artifact) *fakeA2AServer {
+	t.Helper()
+	s := &fakeA2AServer{card: card, tasks: map[string]*Task{}, plan: plan,
+		calls: map[string]int{}, artifacts: artifacts}
+	return s
+}
+
+func (s *fakeA2AServer) handler() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc(WellKnownPath, func(w http.ResponseWriter, r *http.Request) {
+		s.mu.Lock()
+		body, _ := json.Marshal(s.card)
+		s.mu.Unlock()
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write(body)
+	})
+	mux.HandleFunc("/rpc", func(w http.ResponseWriter, r *http.Request) {
+		var req rpcRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			writeRPCError(w, 0, -32700, "parse error")
+			return
+		}
+		s.mu.Lock()
+		defer s.mu.Unlock()
+		s.calls[req.Method]++
+		switch req.Method {
+		case "message/send":
+			id := fmt.Sprintf("task_%d", len(s.tasks)+1)
+			state := StateSubmitted
+			if len(s.plan) > 0 {
+				state = s.plan[0]
+			}
+			task := &Task{Kind: "task", ID: id, ContextID: "ctx_1",
+				Status: TaskStatus{State: state, Message: s.statusMessage()}}
+			s.tasks[id] = task
+			writeRPCResult(w, req.ID, task)
+		case "tasks/get":
+			var params struct {
+				ID string `json:"id"`
+			}
+			raw, _ := json.Marshal(req.Params)
+			_ = json.Unmarshal(raw, &params)
+			task, ok := s.tasks[params.ID]
+			if !ok {
+				writeRPCError(w, req.ID, -32001, "task not found")
+				return
+			}
+			// 按脚本推进状态机（停留在终态）。
+			if !isTerminal(task.Status.State) && len(s.plan) > 0 {
+				n := s.calls["tasks/get#"+params.ID]
+				s.calls["tasks/get#"+params.ID] = n + 1
+				idx := n + 1
+				if idx >= len(s.plan) {
+					idx = len(s.plan) - 1
+				}
+				task.Status.State = s.plan[idx]
+				task.Status.Message = s.statusMessage()
+				if task.Status.State == StateCompleted {
+					task.Artifacts = s.artifacts
+				}
+			}
+			writeRPCResult(w, req.ID, task)
+		default:
+			writeRPCError(w, req.ID, -32601, "method not found")
+		}
+	})
+	return mux
+}
+
+func (s *fakeA2AServer) statusMessage() *Message {
+	if s.statusMsg == "" {
+		return nil
+	}
+	return &Message{Kind: "message", Role: "agent",
+		Parts: []Part{{Kind: "text", Text: s.statusMsg}}}
+}
+
+func writeRPCResult(w http.ResponseWriter, id int64, result any) {
+	body, _ := json.Marshal(result)
+	env, _ := json.Marshal(rpcResponse{JSONRPC: "2.0", ID: id, Result: body})
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write(env)
+}
+
+func writeRPCError(w http.ResponseWriter, id int64, code int, msg string) {
+	env, _ := json.Marshal(rpcResponse{JSONRPC: "2.0", ID: id, Error: &rpcError{Code: code, Message: msg}})
+	w.Header().Set("Content-Type", "application/json")
+	_, _ = w.Write(env)
+}
+
+// ---- 发布侧 ----
+
+func TestBuildCardFromRegistries(t *testing.T) {
+	reg := squad.NewRoleRegistry()
+	for _, r := range []squad.RoleSpec{
+		{Role: "researcher", Name: "调研员", Keywords: []string{"调研", "检索"},
+			Instructions: "围绕目标调研关键问题。\n第二行不进摘要。"},
+		{Role: "writer", Name: "撰稿员", Keywords: []string{"撰写"}},
+	} {
+		if err := reg.Register(r); err != nil {
+			t.Fatal(err)
+		}
+	}
+	bps := squad.NewBlueprintRegistry()
+	if err := bps.Register(squad.Blueprint{Key: "brief", Title: "简报",
+		Description: "生成简报", Match: []string{"简报", "brief"},
+		Steps: []squad.StepSpec{{ID: "s1", Role: "writer", Title: "成文"}}}); err != nil {
+		t.Fatal(err)
+	}
+	card, err := BuildCard(reg, bps, CardOptions{
+		Name: "示例小队", Description: "演示团队能力", URL: "https://team.example/rpc",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if card.ProtocolVersion != ProtocolVersion || card.Version != "1.0.0" {
+		t.Fatalf("card = %+v", card)
+	}
+	byID := map[string]AgentSkill{}
+	for _, s := range card.Skills {
+		byID[s.ID] = s
+	}
+	if byID["researcher"].Name != "调研员" || byID["researcher"].Description != "围绕目标调研关键问题。" {
+		t.Fatalf("role skill = %+v", byID["researcher"])
+	}
+	if len(byID["researcher"].Tags) != 2 {
+		t.Fatalf("tags = %v", byID["researcher"].Tags)
+	}
+	if byID["brief"].Name != "简报" || strings.Join(byID["brief"].Examples, ",") != "简报,brief" {
+		t.Fatalf("blueprint skill = %+v", byID["brief"])
+	}
+	if _, err := BuildCard(reg, bps, CardOptions{}); err == nil {
+		t.Fatal("缺 URL 必须 fail-closed")
+	}
+}
+
+// CardHandler 以 JSON 服务卡片（发布端点形态）。
+func TestCardHandlerServesJSON(t *testing.T) {
+	card := AgentCard{ProtocolVersion: ProtocolVersion, Name: "小队", URL: "https://x/rpc", Version: "1.0.0"}
+	ts := httptest.NewServer(CardHandler(card))
+	defer ts.Close()
+	resp, err := http.Get(ts.URL + WellKnownPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if ct := resp.Header.Get("Content-Type"); ct != "application/json" {
+		t.Fatalf("content-type = %s", ct)
+	}
+	var got AgentCard
+	if err := json.NewDecoder(resp.Body).Decode(&got); err != nil {
+		t.Fatal(err)
+	}
+	if got.Name != "小队" || got.ProtocolVersion != ProtocolVersion {
+		t.Fatalf("card = %+v", got)
+	}
+}
+
+// ---- 消费侧：发现 + 状态机 ----
+
+func TestFetchCardAndExecuteCompleted(t *testing.T) {
+	fileBytes := base64.StdEncoding.EncodeToString([]byte("notes 内容"))
+	artifacts := []Artifact{{
+		ArtifactID: "art1", Name: "调研结果",
+		Parts: []Part{
+			{Kind: "text", Text: "# 调研结论\n\n结论正文，长度足够作为交付物内容。"},
+			{Kind: "file", File: &FilePart{Name: "notes.md", Bytes: fileBytes, MimeType: "text/markdown"}},
+		},
+	}}
+	card := AgentCard{ProtocolVersion: ProtocolVersion, Name: "远端小队",
+		URL: "PLACEHOLDER", Version: "1.0.0"}
+	srv := newFakeServer(t, card, []string{StateWorking, StateWorking, StateCompleted}, artifacts)
+	ts := httptest.NewServer(srv.handler())
+	defer ts.Close()
+	srv.mu.Lock()
+	srv.card.URL = ts.URL + "/rpc"
+	srv.mu.Unlock()
+
+	// 发现：well-known 路径取卡并校验。
+	got, err := FetchCard(ts.Client(), ts.URL+WellKnownPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.Name != "远端小队" || got.URL != ts.URL+"/rpc" {
+		t.Fatalf("card = %+v", got)
+	}
+
+	// 执行：submitted/working → completed，工件映射 patches。
+	var states []string
+	ex := NewExecutor(got)
+	ex.Client = ts.Client()
+	ex.PollInterval = 5 * time.Millisecond
+	ex.OnState = func(s string) { states = append(states, s) }
+	res, err := ex.Execute(context.Background(), squad.ExecRequest{
+		Prompt: "调研主题 X", Targets: []string{"output.md"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Success {
+		t.Fatalf("result = %+v", res)
+	}
+	if string(res.Patches["notes.md"]) != "notes 内容" {
+		t.Fatalf("file part 未落成 patch：%q", res.Patches["notes.md"])
+	}
+	if !strings.Contains(string(res.Patches["output.md"]), "调研结论") {
+		t.Fatalf("文本部件未写入目标：%q", res.Patches["output.md"])
+	}
+	joined := strings.Join(states, ",")
+	if !strings.Contains(joined, StateWorking) || !strings.HasSuffix(joined, StateCompleted) {
+		t.Fatalf("状态机迁移 = %v", states)
+	}
+	srv.mu.Lock()
+	sends := srv.calls["message/send"]
+	srv.mu.Unlock()
+	if sends != 1 {
+		t.Fatalf("message/send = %d", sends)
+	}
+}
+
+func TestExecuteMapsFailedAndInputRequired(t *testing.T) {
+	card := AgentCard{ProtocolVersion: ProtocolVersion, Name: "远端", URL: "PLACEHOLDER", Version: "1"}
+	srv := newFakeServer(t, card, []string{StateWorking, StateFailed}, nil)
+	srv.statusMsg = "远端执行崩溃"
+	ts := httptest.NewServer(srv.handler())
+	defer ts.Close()
+	srv.mu.Lock()
+	srv.card.URL = ts.URL + "/rpc"
+	srv.mu.Unlock()
+
+	ex := NewExecutor(card)
+	ex.BaseURL = ts.URL + "/rpc"
+	ex.Client = ts.Client()
+	ex.PollInterval = 5 * time.Millisecond
+	res, err := ex.Execute(context.Background(), squad.ExecRequest{Prompt: "x", Targets: []string{"output.md"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Success || !strings.Contains(res.ErrorReason, "failed") || !strings.Contains(res.ErrorReason, "远端执行崩溃") {
+		t.Fatalf("failed 映射 = %+v", res)
+	}
+
+	// input-required：fail-closed（跨进程人工输入不在适配面内）。
+	srv2 := newFakeServer(t, card, []string{StateInputRequired}, nil)
+	srv2.statusMsg = "请补充授权"
+	ts2 := httptest.NewServer(srv2.handler())
+	defer ts2.Close()
+	ex2 := &Executor{BaseURL: ts2.URL + "/rpc", Client: ts2.Client(), PollInterval: 5 * time.Millisecond}
+	res2, err := ex2.Execute(context.Background(), squad.ExecRequest{Prompt: "x", Targets: []string{"output.md"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res2.Success || !strings.Contains(res2.ErrorReason, "input-required") {
+		t.Fatalf("input-required 映射 = %+v", res2)
+	}
+}
+
+// 直接回 Message（无任务态）→ 文本落目标。
+func TestExecuteDirectMessageResult(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req rpcRequest
+		_ = json.NewDecoder(r.Body).Decode(&req)
+		writeRPCResult(w, req.ID, Message{Kind: "message", Role: "agent",
+			Parts: []Part{{Kind: "text", Text: "直接回答正文"}}})
+	}))
+	defer ts.Close()
+	ex := &Executor{BaseURL: ts.URL, Client: ts.Client()}
+	res, err := ex.Execute(context.Background(), squad.ExecRequest{Prompt: "x", Targets: []string{"output.md"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Success || !strings.Contains(string(res.Patches["output.md"]), "直接回答正文") {
+		t.Fatalf("res = %+v", res)
+	}
+}
+
+// 传输/协议错误 → error（引擎按瞬态评估），不吞成成功。
+func TestExecuteProtocolErrors(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writeRPCError(w, 1, -32601, "method not found")
+	}))
+	defer ts.Close()
+	ex := &Executor{BaseURL: ts.URL, Client: ts.Client()}
+	if _, err := ex.Execute(context.Background(), squad.ExecRequest{Prompt: "x"}); err == nil ||
+		!strings.Contains(err.Error(), "协议错误") {
+		t.Fatalf("err = %v", err)
+	}
+	// ctx 取消传播。
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	slow := newFakeServer(t, AgentCard{ProtocolVersion: "1.0", Name: "x", URL: ts.URL, Version: "1"},
+		[]string{StateWorking}, nil)
+	ts2 := httptest.NewServer(slow.handler())
+	defer ts2.Close()
+	ex2 := &Executor{BaseURL: ts2.URL + "/rpc", Client: ts2.Client(), PollInterval: time.Second}
+	if _, err := ex2.Execute(ctx, squad.ExecRequest{Prompt: "x"}); err == nil {
+		t.Fatal("取消必须传播")
+	}
+}
+
+// FetchCard fail-closed：缺必备字段拒绝。
+func TestFetchCardValidates(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`{"protocolVersion":"1.0","name":"","url":"","version":""}`))
+	}))
+	defer ts.Close()
+	if _, err := FetchCard(ts.Client(), ts.URL); err == nil || !strings.Contains(err.Error(), "name") {
+		t.Fatalf("err = %v", err)
+	}
+}

adapters/a2a/executor.go

@@ -0,0 +1,331 @@
+package a2a
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"agent-squad/squad"
+)
+
+// executor.go — 远端智能体 Executor 客户端（A2A 任务状态机对齐 ExecResult）。
+
+// 任务状态（A2A 1.0 TaskState）。
+const (
+	StateSubmitted    = "submitted"
+	StateWorking      = "working"
+	StateInputRequired = "input-required"
+	StateCompleted    = "completed"
+	StateCanceled     = "canceled"
+	StateFailed       = "failed"
+	StateRejected     = "rejected"
+)
+
+// DefaultPollInterval 是 tasks/get 轮询缺省间隔。
+const DefaultPollInterval = 500 * time.Millisecond
+
+// Executor 把远端 A2A 智能体接成 squad.Executor：一次步骤执行 = 一个
+// A2A 任务（message/send 发起，tasks/get 轮询到终态）。
+type Executor struct {
+	// BaseURL 远端 JSON-RPC 端点（Agent Card 的 url）。
+	BaseURL string
+	// Client HTTP 客户端（nil = http.DefaultClient）。
+	Client *http.Client
+	// PollInterval 轮询间隔（0 = DefaultPollInterval）。
+	PollInterval time.Duration
+	// OnState 可选状态回调（观测任务状态机迁移）。
+	OnState func(state string)
+
+	callID atomic.Int64
+}
+
+// NewExecutor 按 Agent Card 构造远端执行器。
+func NewExecutor(card AgentCard) *Executor {
+	return &Executor{BaseURL: card.URL}
+}
+
+// Name 实现 squad.Executor。
+func (e *Executor) Name() string { return "a2a" }
+
+// ---- A2A 1.0 报文形态（JSON-RPC 2.0） ----
+
+type rpcRequest struct {
+	JSONRPC string `json:"jsonrpc"`
+	ID      int64  `json:"id"`
+	Method  string `json:"method"`
+	Params  any    `json:"params"`
+}
+
+type rpcError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type rpcResponse struct {
+	JSONRPC string          `json:"jsonrpc"`
+	ID      int64           `json:"id"`
+	Result  json.RawMessage `json:"result,omitempty"`
+	Error   *rpcError       `json:"error,omitempty"`
+}
+
+// Part 是消息/工件的部件（text | file | data）。
+type Part struct {
+	Kind string     `json:"kind"`
+	Text string     `json:"text,omitempty"`
+	File *FilePart  `json:"file,omitempty"`
+	Data *json.RawMessage `json:"data,omitempty"`
+}
+
+// FilePart 文件部件：bytes（base64）或 uri 二选一。
+type FilePart struct {
+	Name     string `json:"name"`
+	Bytes    string `json:"bytes,omitempty"`
+	URI      string `json:"uri,omitempty"`
+	MimeType string `json:"mimeType,omitempty"`
+}
+
+// Message 是一条 A2A 消息。
+type Message struct {
+	Kind      string `json:"kind"`
+	Role      string `json:"role"`
+	Parts     []Part `json:"parts"`
+	MessageID string `json:"messageId"`
+}
+
+// TaskStatus 任务状态。
+type TaskStatus struct {
+	State    string   `json:"state"`
+	Message  *Message `json:"message,omitempty"`
+	Timestamp string  `json:"timestamp,omitempty"`
+}
+
+// Artifact 任务工件。
+type Artifact struct {
+	ArtifactID string `json:"artifactId,omitempty"`
+	Name       string `json:"name,omitempty"`
+	Parts      []Part `json:"parts"`
+}
+
+// Task 是 A2A 任务（状态机载体）。
+type Task struct {
+	Kind      string     `json:"kind"`
+	ID        string     `json:"id"`
+	ContextID string     `json:"contextId,omitempty"`
+	Status    TaskStatus `json:"status"`
+	Artifacts []Artifact `json:"artifacts,omitempty"`
+}
+
+// Execute 实现 squad.Executor：发起任务并轮询到终态，映射 ExecResult。
+// 传输/协议错误返回 error（引擎按瞬态失败评估）；任务级失败
+// （failed/canceled/rejected/input-required）返回 Success=false 的结果
+// （fail-closed：跨进程人工输入不在本适配面内）。
+func (e *Executor) Execute(ctx context.Context, req squad.ExecRequest) (*squad.ExecResult, error) {
+	if strings.TrimSpace(e.BaseURL) == "" {
+		return nil, fmt.Errorf("a2a: executor 缺 BaseURL")
+	}
+	prompt := strings.TrimSpace(req.Prompt)
+	if prompt == "" {
+		prompt = strings.TrimSpace(req.Instructions)
+	}
+	msg := Message{
+		Kind: "message", Role: "user",
+		Parts:     []Part{{Kind: "text", Text: prompt}},
+		MessageID: fmt.Sprintf("msg-%d-%d", time.Now().UnixNano(), e.callID.Add(1)),
+	}
+	raw, err := e.call(ctx, "message/send", map[string]any{"message": msg})
+	if err != nil {
+		return nil, err
+	}
+	// 服务端可直接回 Message（无任务态）或 Task。
+	var probe struct {
+		Kind string `json:"kind"`
+	}
+	_ = json.Unmarshal(raw, &probe)
+	if probe.Kind == "message" {
+		var m Message
+		if err := json.Unmarshal(raw, &m); err != nil {
+			return nil, fmt.Errorf("a2a: message 结果解析失败: %w", err)
+		}
+		return e.resultFromParts(m.Parts, req.Targets), nil
+	}
+	var task Task
+	if err := json.Unmarshal(raw, &task); err != nil {
+		return nil, fmt.Errorf("a2a: task 结果解析失败: %w", err)
+	}
+	e.observe(task.Status.State)
+	if shouldStop(task.Status.State) {
+		return e.resultFromTask(task, req.Targets), nil
+	}
+	// 轮询任务状态机直至终态（ctx 取消传播）。
+	interval := e.PollInterval
+	if interval <= 0 {
+		interval = DefaultPollInterval
+	}
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		case <-ticker.C:
+		}
+		raw, err := e.call(ctx, "tasks/get", map[string]any{"id": task.ID})
+		if err != nil {
+			return nil, err
+		}
+		var next Task
+		if err := json.Unmarshal(raw, &next); err != nil {
+			return nil, fmt.Errorf("a2a: tasks/get 解析失败: %w", err)
+		}
+		if next.Status.State != task.Status.State {
+			task = next
+			e.observe(task.Status.State)
+		} else {
+			task = next
+		}
+		if shouldStop(task.Status.State) {
+			return e.resultFromTask(task, req.Targets), nil
+		}
+	}
+}
+
+// call 发一次 JSON-RPC 调用并取 result。
+func (e *Executor) call(ctx context.Context, method string, params any) (json.RawMessage, error) {
+	client := e.Client
+	if client == nil {
+		client = http.DefaultClient
+	}
+	body, _ := json.Marshal(rpcRequest{
+		JSONRPC: "2.0", ID: e.callID.Add(1), Method: method, Params: params,
+	})
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.BaseURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("a2a: %s 传输失败: %w", method, err)
+	}
+	defer resp.Body.Close()
+	data, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+	if err != nil {
+		return nil, fmt.Errorf("a2a: %s 读取响应失败: %w", method, err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("a2a: %s 返回 HTTP %d", method, resp.StatusCode)
+	}
+	var env rpcResponse
+	if err := json.Unmarshal(data, &env); err != nil {
+		return nil, fmt.Errorf("a2a: %s 响应不是合法 JSON-RPC: %w", method, err)
+	}
+	if env.Error != nil {
+		return nil, fmt.Errorf("a2a: %s 协议错误 %d: %s", method, env.Error.Code, env.Error.Message)
+	}
+	return env.Result, nil
+}
+
+func (e *Executor) observe(state string) {
+	if e.OnState != nil {
+		e.OnState(state)
+	}
+}
+
+func isTerminal(state string) bool {
+	switch state {
+	case StateCompleted, StateFailed, StateCanceled, StateRejected:
+		return true
+	}
+	return false
+}
+
+// shouldStop 轮询停止条件：真终态，或 input-required（跨进程人工输入不在
+// 本适配面内，fail-closed 交引擎语义处理，不死等）。
+func shouldStop(state string) bool {
+	return isTerminal(state) || state == StateInputRequired
+}
+
+// resultFromTask 终态任务 → ExecResult。
+func (e *Executor) resultFromTask(task Task, targets []string) *squad.ExecResult {
+	switch task.Status.State {
+	case StateCompleted:
+		var parts []Part
+		for _, art := range task.Artifacts {
+			parts = append(parts, art.Parts...)
+		}
+		return e.resultFromParts(parts, targets)
+	case StateInputRequired:
+		return &squad.ExecResult{Success: false,
+			ErrorReason: "a2a: 远端要求人工输入（input-required）：" + statusText(task.Status)}
+	case StateCanceled:
+		return &squad.ExecResult{Success: false,
+			ErrorReason: "a2a: 远端任务被取消（canceled）：" + statusText(task.Status)}
+	case StateRejected:
+		return &squad.ExecResult{Success: false,
+			ErrorReason: "a2a: 远端拒绝任务（rejected）：" + statusText(task.Status)}
+	default: // failed 及未知终态一律 fail-closed
+		return &squad.ExecResult{Success: false,
+			ErrorReason: "a2a: 远端任务失败（" + task.Status.State + "）：" + statusText(task.Status)}
+	}
+}
+
+// resultFromParts 部件流 → patches：FilePart(bytes) 按名落 patch；
+// 文本部件拼接后写入全部声明目标（无文件工件时的交付物兜底，
+// 与其他后端「正文写目标文件」契约一致）。
+func (e *Executor) resultFromParts(parts []Part, targets []string) *squad.ExecResult {
+	patches := map[string][]byte{}
+	var text strings.Builder
+	for _, p := range parts {
+		switch p.Kind {
+		case "text":
+			if text.Len() > 0 {
+				text.WriteString("\n")
+			}
+			text.WriteString(p.Text)
+		case "file":
+			if p.File == nil || p.File.Name == "" {
+				continue
+			}
+			data, err := base64.StdEncoding.DecodeString(p.File.Bytes)
+			if err != nil {
+				continue // uri 形态与坏 base64 不落 patch（消费侧最小面）
+			}
+			patches[p.File.Name] = data
+		}
+	}
+	body := strings.TrimSpace(text.String())
+	if len(targets) == 0 {
+		targets = []string{"output.md"}
+	}
+	if body != "" {
+		for _, t := range targets {
+			if _, ok := patches[t]; !ok {
+				patches[t] = []byte(body + "\n")
+			}
+		}
+	}
+	if len(patches) == 0 {
+		return &squad.ExecResult{Success: false, ErrorReason: "a2a: 完成任务无任何工件"}
+	}
+	return &squad.ExecResult{Success: true, Patches: patches, Logs: body}
+}
+
+func statusText(st TaskStatus) string {
+	if st.Message == nil {
+		return ""
+	}
+	var b strings.Builder
+	for _, p := range st.Message.Parts {
+		if p.Kind == "text" {
+			b.WriteString(p.Text)
+		}
+	}
+	return b.String()
+}

adapters/a2a/go.mod

@@ -0,0 +1,11 @@
+module agent-squad/adapters/a2a
+
+go 1.27
+
+require agent-squad v0.0.0
+
+require error-code-system v0.0.0 // indirect
+
+replace agent-squad => ../..
+
+replace error-code-system => ../../deps/error-code-system

policy/guidelines-adoption.md

@@ -1,24 +1,26 @@
 # 通用规范采纳记录
 
-- 项目/负责人：Agent-Squad / 仓库所有者 weichen
+- 项目/负责人：Agent-Squad / weichen
 - 状态：active
 - 规范位置：`deps/development-guidelines`
 - 规范性文档目录：`policy/`
-- 过程文档位置：`docs/records/`（项目内固定目录豁免。个人维护的编排库，任务主记录仍在 Gitea Issue/PR。过程记录不进规范库，也不写成与 Issue 平行的第二状态。）
+- 过程文档位置：任务卡在 `.task/`（`.task/feature-governance-adoption.md`）；任务主记录在 Gitea PR 中维护。既有过程记录仍按项目内固定目录豁免留在 `docs/records/`。过程记录不进规范库，也不写成与 Issue/PR 平行的第二状态。
-- 版本权威：父仓 gitlink；可读标签：无（内容版本 `0.1.0-draft.6`，提交 `26b562d2e34fbc560711296a309c91c74ffc55b1`）
+- 版本权威：本仓 gitlink deps/development-guidelines @ 2688fd2be6a5（完整 `2688fd2be6a52c0bf110e7e6366b6f291ab5e4eb`，内容版本 `0.1.0-draft.12`，无已发布标签）
-- 批准/生效依据：本仓接入提交
+- 批准/生效依据：`feature/governance-adoption PR（Agent-Squad）`
-- 替代范围和迁移说明：本仓此前没有根 `AGENTS.md`。Agent-Native 子模块已从仓库根迁到 `deps/agent-native`，迁移说明见 `docs/records/2026-09-29-guidelines-and-observability.md`。
+- 替代范围和迁移说明：本次替代 2026-09-29 采纳的固定版本 `26b562d2e34f`（内容版本 `0.1.0-draft.6`），规则条目按 `0.1.0-draft.12` 重新核对。新增 `AGENT-EXECUTION.md` 执行路由、`deps/development-manager` gitlink（`bd3a7de57a3a`）、`scripts/dm`、`scripts/agent-exec`、`scripts/task`、`scripts/hooks/pre-commit`、`.gitea/workflows/governance.yml` 与任务卡模板。不改业务代码，不改既有 `.gitea/workflows/ci.yml`。此前迁移说明见 `docs/records/2026-09-29-guidelines-and-observability.md`。
 
 | 规范/工作流 | 适用条件与范围 | 采纳或不适用理由 | 执行方式/证据 |
 |---|---|---|---|
 | core/baseline.md | 日常工作 | 编排库对外有失败关闭语义 | manual |
 | workflows/delivery.md、debugging.md、handoff.md | 交付、排障与交接 | 跨仓组合需要可交接记录 | manual |
 | standards/collaboration.md | 并行共同起点与组合升级 | 父仓 gitlink 锁定 Agent-Native 与基础库 | manual |
-| standards/verification.md | 验证与结论 | `GOWORK=off go test` | manual；命令见 PROJECT.md |
+| standards/merge-queue.md | 多个就绪任务的最终同步、CI、Review 与合入调度 | 多个 agent 单元并行开发，合入须串行同步；协调者为仓库所有者 | manual |
+| standards/verification.md | 验证与结论 | `GOWORK=off go test` | manual；命令见 PROJECT.md（含 `scripts/agent-exec validate --repo .`、`scripts/dm governance check --repo .`） |
 | workflows/design-verification.md、standards/testability.md、standards/failure-containment.md | 规划、执行、HITL | conformance 覆盖公开 API | manual |
 | standards/module-contracts.md | squad 与 agent-native 边界 | 依赖方向只允许 squad → agent-native | manual |
 | standards/observability.md | HTTP 信封、trace、事件 | 接入错误码库与日志库 | manual |
-| standards/agent-execution.md | 角色绑定的执行后端 | 本库不实现 Agent | manual |
+| standards/agent-execution.md | 工程 Agent CLI 执行路由、会话隔离与受控集成 | 凡允许 AI 协助工程变更必须采纳；路由配置见 AGENT-EXECUTION.md；本库不实现 Agent | 执行方式：AGENT-EXECUTION.md + scripts/agent-exec（validate / admit）；证据：`governance check + 正负例（.task/feature-governance-adoption.md）` |
+| standards/tool-adaptation.md | 为具体工具创建规则与钩子 | 本次引入 `scripts/hooks/pre-commit`（启用由 host/人执行，`core.hooksPath`） | manual；启用后以本仓 pre-commit 检查为证据 |
 | standards/multi-repo.md | 多级 submodule | 本仓 replace 是编译时的唯一依赖解析 | manual |
 | standards/data-reliability.md | 运行目录、HITL 恢复、幂等回应 | 磁盘为权威 | manual |
 | standards/security.md | bash 权限挂起、脱敏 | 事件落盘沿用现有脱敏；凭证走环境变量 | manual |
@@ -31,14 +33,17 @@
 
 | 原规则/章节 | 项目采用方式 | 原因与风险 | 负责人/复查条件 |
 |---|---|---|---|
-| documentation.md 过程仓默认独立仓库 | 过程记录放 `docs/records/` | 同 Agent-Native：避免个人项目再维护一个过程仓。风险是证据与代码同库 | 多人协作或对外发布时复查 |
+| documentation.md 过程仓默认独立仓库 | 其他过程记录放 `docs/records/`（既有过程记录的项目内固定目录豁免） | 同 Agent-Native：避免个人项目再维护一个过程仓。风险是过程记录与代码同库 | 多人协作或对外发布时复查 |
+| documentation.md 过程仓默认独立仓库 | 任务卡与交付证据放 `.task/`（模板 `.task/templates/task-card.md`） | 任务状态仍只认 Gitea Issue/PR，`.task/` 不写成平行状态；风险是任务卡与代码同库 | 多人协作或对外发布时复查 |
 | multi-repo.md 组件说明不手写第二套 SHA | PROJECT.md 只写路径与角色，SHA 以 `git submodule status` 为准 | 手抄 SHA 会与 gitlink 漂移 | 每次依赖升级核对脚本 |
 
 ## 本次升级或首次接入验证
 
-- `deps/development-guidelines` 固定 `26b562d2e34fbc560711296a309c91c74ffc55b1`。
+- `deps/development-guidelines` 固定 `2688fd2be6a52c0bf110e7e6366b6f291ab5e4eb`（内容版本 `0.1.0-draft.12`）；`deps/development-manager` 固定 `bd3a7de57a3a9e1a4495b94c5fa5c08d71e7be8c`。
-- 执行方式为 manual。
+- 工程 Agent 执行：`AGENT-EXECUTION.md` 为唯一路由权威；AI 实施单元只经 `scripts/agent-exec run` 执行，并经 `scripts/agent-exec apply` 集成。`scripts/agent-exec` 与 `scripts/task` 只是转调 `scripts/dm` 的薄入口。
-- 回退该规范挂载时，同时确认 Agent-Native 子模块路径是否已迁移；只还原规范 gitlink 不会把 `deps/agent-native` 移回根目录。
+- 登记为 active 的前置证据：一次成功执行正例（有效 `completed` 收据经 transport/admission 集成）；缺配置、无效终态收据、越权路径、未知副作用四类负例均被拒绝或 fail-stop。证据按 `.task/feature-governance-adoption.md` 记录。
+- 入口核验：`scripts/dm governance check --repo .` 与 `scripts/agent-exec validate --repo .`（PROJECT.md「验证」节）。CI 由 `.gitea/workflows/governance.yml` 执行；既有 `ci.yml` 未改。
+- 回退该规范挂载时，恢复上一已批准 gitlink `26b562d2e34f`，并同时还原本次新增的治理脚本与 `governance.yml`；如已启用 `core.hooksPath`，需一并关闭。只还原规范 gitlink 不会把 `deps/agent-native` 移回根目录。
 
 ### 2026-09-29 追加：agent-intent 可选意图闸门
 

scripts/agent-exec

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# 共享 Agent 执行器薄入口：转调 scripts/dm 的 agent-exec 子命令（validate / run / apply / admit / cleanup）。
+set -euo pipefail
+exec "$(dirname "$0")/dm" agent-exec "$@"

scripts/dm

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# 共享 dm-server 薄入口：读取 deps/development-manager 的 gitlink 钉住提交，
+# 按该提交构建并缓存 dm-server，再 exec 其子命令（agent-exec、task、governance）。执行语义与退出码以该二进制为准。
+set -euo pipefail
+
+root=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)
+dm="$root/deps/development-manager"
+
+die() { echo "dm: $*" >&2; exit 2; }
+
+# git 钩子会导出仓库本地变量（GIT_DIR、GIT_INDEX_FILE 等），它们会让 `git -C "$dm"` 解析到外层仓库。
+# 所有针对 DM 检出的 git 与 go 调用都在清除这些变量后执行；读取外层 gitlink 与最终 exec 仍保留继承环境。
+dm_local_env="GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE GIT_PREFIX GIT_OBJECT_DIRECTORY GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_GRAFT_FILE GIT_NAMESPACE GIT_CONFIG GIT_CONFIG_PARAMETERS GIT_CONFIG_COUNT GIT_SHALLOW_FILE GIT_IMPLICIT_WORK_TREE $(git rev-parse --local-env-vars 2>/dev/null || true)"
+dm_clean_env() { for v in $dm_local_env; do unset "$v"; done; }
+dmgit() ( dm_clean_env; git -C "$dm" "$@" )
+
+# 1. 钉住版本只来自索引中的 gitlink（mode 160000），不读取工作区文件。
+entry=$(git -C "$root" ls-files -s -- deps/development-manager 2>/dev/null || true)
+[ -n "$entry" ] || die "索引中缺少 deps/development-manager 的 gitlink，无法确定钉住的 DM 版本"
+read -r mode pin _stage _path <<<"$entry"
+[ "$mode" = 160000 ] || die "deps/development-manager 不是 gitlink（mode=$mode）"
+[[ "$pin" =~ ^[0-9a-f]{40}$ ]] || die "gitlink 提交格式无效：$pin"
+
+# 2. 检出必须存在且确为 DM 独立仓库（避免 git -C 误解析到外层仓库），HEAD 必须等于钉住提交。
+[ -e "$dm/.git" ] || die "deps/development-manager 未检出；请按钉住提交 $pin 检出该 gitlink"
+top=$(dmgit rev-parse --show-toplevel 2>/dev/null || true)
+[ -n "$top" ] && [ "$top" = "$(cd "$dm" && pwd -P)" ] \
+  || die "deps/development-manager 不是独立检出；请按钉住提交 $pin 检出该 gitlink"
+head=$(dmgit rev-parse HEAD 2>/dev/null || true)
+[ "$head" = "$pin" ] \
+  || die "deps/development-manager HEAD（${head:-未知}）与钉住提交 $pin 不一致；请按钉住提交检出"
+
+# 3. 检出工作树必须干净（忽略嵌套 submodule 状态）。
+dirty=$(dmgit status --porcelain --ignore-submodules=all) \
+  || die "无法读取 deps/development-manager 的工作树状态"
+[ -z "$dirty" ] || die "deps/development-manager 存在未提交改动，拒绝运行（请先清理该检出）"
+
+# 4. 二进制按钉住提交缓存；缺失时在缓存目录内临时构建，完成后原子改名，避免留下半成品。
+cache="${DM_CACHE:-${XDG_CACHE_HOME:-$HOME/.cache}/development-manager/dm-server}"
+bin="$cache/dm-server-$pin"
+if [ ! -x "$bin" ]; then
+  command -v go >/dev/null 2>&1 || die "缺少 go，无法构建 dm-server（$pin）"
+  mkdir -p "$cache"
+  cache=$(cd "$cache" && pwd -P)
+  bin="$cache/dm-server-$pin"
+  work=$(mktemp -d "$cache/build-$pin.XXXXXX")
+  if ! (dm_clean_env; cd "$dm" && GOWORK=off go build -trimpath -o "$work/dm-server" ./cmd/dm-server); then
+    rm -rf "$work"
+    die "构建 dm-server 失败（$pin）"
+  fi
+  mv -f "$work/dm-server" "$bin"
+  rm -rf "$work"
+fi
+
+exec "$bin" "$@"

scripts/hooks/pre-commit

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# 本地检查（pre-commit）：集成分支直提拒绝 + 分支命名 + 本地完整性核对。权威准入在 PR（baseline.md:26）。
+branch=$(git rev-parse --abbrev-ref HEAD)
+case "$branch" in
+  main|master)
+    echo "pre-commit: 拒绝——集成分支 ${branch} 不得直接提交，走 feature 分支 + PR（collaboration.md）" >&2
+    exit 1 ;;
+esac
+echo "$branch" | grep -qE '^(feature|fix|hotfix|release)/[A-Za-z0-9._-]+$' || {
+  echo "pre-commit: 拒绝——分支名须为 feature|fix|hotfix|release/<slug>，当前：${branch}" >&2
+  exit 1
+}
+root=$(git rev-parse --show-toplevel)
+# admit 只是本地完整性/篡改证据（SELF）：同一 OS 用户可读取本地 HMAC 密钥并绕过本钩子，
+# 它不是 GATE，也不是可信身份。缺失或无效的本地记录仍拒绝；交付信任来自精确 HEAD 的 CI 或独立 REPLAY。
+"$root/scripts/agent-exec" admit --repo "$root"

scripts/task

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# 通用任务入口：转调 scripts/dm 的 task 子命令（triage / start / pr-check）。
+set -euo pipefail
+exec "$(dirname "$0")/dm" task "$@"

squad/brief_test.go

@@ -0,0 +1,41 @@
+package squad
+
+import (
+	"context"
+	"strings"
+	"testing"
+)
+
+// brief_test.go — Q3 WP1a：StepSpec.Brief 渲染进 TASK.md「任务指令」节。
+
+func TestStepBriefRendersIntoTaskFile(t *testing.T) {
+	rec := &promptRecordingBackend{prompts: map[string][]string{}}
+	engine := newRecordingEngine(t, rec, []StepSpec{
+		{ID: "s1", Role: "researcher", Title: "起草", Targets: []string{"output.md"},
+			Brief: "写一份关于「太空电梯」的简报，篇幅：短。\n必须包含单独一行「核对标记：P4」。"},
+	})
+	res, err := engine.Run(context.Background(), Goal{Text: "带任务指令"}, RunOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Status != RunCompleted {
+		t.Fatalf("status = %s err = %v", res.Status, res.Error)
+	}
+	var prompt string
+	for _, p := range rec.prompts["01_researcher"] {
+		prompt += p
+	}
+	if !strings.Contains(prompt, "## 任务指令") {
+		t.Fatalf("TASK.md 缺任务指令节：%q", prompt)
+	}
+	if !strings.Contains(prompt, "核对标记：P4") {
+		t.Fatalf("任务指令正文缺失：%q", prompt)
+	}
+	// 指令节在期望产出之后、上下文表之前。
+	iOut := strings.Index(prompt, "期望产出")
+	iBrief := strings.Index(prompt, "## 任务指令")
+	iCtx := strings.Index(prompt, "## 任务上下文资源")
+	if !(iOut < iBrief && iBrief < iCtx) {
+		t.Fatalf("任务指令节位置错误：%d/%d/%d", iOut, iBrief, iCtx)
+	}
+}

squad/models.go

@@ -128,6 +128,10 @@ type StepSpec struct {
 	Branches []Branch `json:"branches,omitempty"`
 	// Handoff 非空 = 完成即把最终答案所有权移交给该角色（Q2 handoff 原语）。
 	Handoff string `json:"handoff,omitempty"`
+	// Brief 编译期任务指令（Q3 编译器）：非空时渲染进 TASK.md 的
+	// 「任务指令」节，位于标题/产出之后、上下文表之前。图步的富文本任务书
+	// 载体（此前只有 leader 委派有 briefing）。
+	Brief string `json:"brief,omitempty"`
 }
 
 // LoopSpec 是循环步的预算与停机条件（Q2）。

squad/workspace.go

@@ -189,6 +189,13 @@ func (e *WorkspaceEngine) writeTaskFile(subDir string, step *StepSpec, role Role
 	fmt.Fprintf(&b, "- 角色：%s（%s）\n", role.Name, role.Role)
 	fmt.Fprintf(&b, "- 期望产出：%v\n\n", step.Targets)
 
+	// 编译期任务指令（Q3）：编译器渲染好的富文本任务书，权威仅次于目标。
+	if strings.TrimSpace(step.Brief) != "" {
+		b.WriteString("## 任务指令\n\n")
+		b.WriteString(strings.TrimSpace(step.Brief))
+		b.WriteString("\n\n")
+	}
+
 	b.WriteString("## 任务上下文资源与权威等级（已快照到本目录，只引用本地路径）\n\n")
 	b.WriteString("| 资源路径 | 权威等级 | 用途说明 | 使用与引用指导 |\n|---|---|---|---|\n")
 	b.WriteString("| `context/goal.md` | **authoritative** | 运行目标 | 不可推翻 |\n")