easy-coding-harness 0.10.0-beta.2 → 0.10.0-beta.4

package/CHANGELOG.md

@@ -6,6 +6,30 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.10.0-beta.4
+
+- ANALYSIS 完成后不再向会话回贴整份 `dev-spec.md`，改为展示核心方案、验收摘要、
+  Workflow Mode 与主要风险，并在客户端支持时提供完整 Dev-Spec 的绝对 Markdown 文件链接，
+  不支持本地链接时保留可复制的绝对路径。
+- Dev-Spec 新增结构化“决策闭环”章节；技术路线、接口、模型、状态、范围或验收存在未决问题时，
+  Agent 必须停留在 ANALYSIS 逐项问答并回填结论。状态 API 要求唯一的
+  `decision_status: closed` 标记，未闭合方案不能进入 IMPLEMENT。
+- `ec-implementing` 新增注释交付门禁：作者署名必须使用当前宿主 Agent 与 Easy Coding 的组合，
+  例如 `Codex with Easy Coding`；新增数据模型字段、枚举成员和常量必须逐项说明语义及适用的
+  单位、格式、取值、空值或兼容约束。
+
+## 0.10.0-beta.3
+
+- TDD 业务任务的 `VERIFICATION` 门禁收口为本地证据：每个仓库（Canonical 场景下每个
+  source task）必须有通过的本地单测，以及达到冻结阈值的本地 JaCoCo changed-line
+  coverage；不再要求远程 GitLab pipeline URL、job identity 或成功状态。
+- `ec-tdd-init` 继续在 TDD 关闭态生成并校验参数化 GitLab TEST-stage job、构建配置、
+  JaCoCo XML 与 readiness receipt，但远程 CI 只作为项目自动化能力，不再触发 Harness
+  中间提交、推送或等待远程结果。
+- beta.1/beta.2 任务中已有的 `coverage_scope=gitlab` 记录保持原样并从新验收集合中忽略，
+  因此 pending/failed 远程记录不会阻塞升级后的本地门禁；本地 baseline、阈值、报告
+  指纹及 TDD 生命周期/review 约束保持不变。
+
 ## 0.10.0-beta.2
 
 - 新增 `ec-tdd-init`，在 TDD 关闭态初始化或刷新 Java 单测执行、JaCoCo XML、GitLab

package/README.md

@@ -86,7 +86,10 @@ any stage --[user abort via ec-task-close]--> CLOSED
   ANALYSIS → IMPLEMENT 确认一次，随后各阶段在质量门禁通过后自动推进，`auto` 从开始即
   自动推进。
 - 工作流模式优先级为 session 覆盖 > 项目 `behavior.workflow_mode` > `adaptive`。Adaptive 在 ANALYSIS 结束时根据风险解析、展示并冻结为 `fast`、`standard` 或 `strict`，用户可在风险下限之上调整。
-- Java TDD 默认关闭；优先级为 session 覆盖 > 项目配置 > `false/90%`。首次开启前必须运行 `ec-tdd-init`，只建设 JUnit/JaCoCo/GitLab 增量覆盖率基础设施，不补存量业务单测；readiness 通过后才允许显式开启。开启后在 ANALYSIS → IMPLEMENT 冻结开关、baseline 与阈值，只验收本任务新增/修改生产代码行，执行 RED/GREEN/REFACTOR（纯重构使用 characterization GREEN → GREEN），并以同一工具执行本地与 GitLab TEST-stage 差异覆盖率门禁。关闭时普通任务不扫描 CI/JaCoCo、不增加命令或提高原工作流验收深度。
+- ANALYSIS 会先通过问答闭合影响技术路线、接口、模型、状态、范围或验收的实质性问题，
+  并在 Dev-Spec 中记录唯一的 `decision_status: closed`。会话只展示核心方案、验收摘要、
+  Workflow Mode 与主要风险；完整 `dev-spec.md` 通过绝对本地链接或路径按需查看。
+- Java TDD 默认关闭；优先级为 session 覆盖 > 项目配置 > `false/90%`。首次开启前必须运行 `ec-tdd-init`，只建设 JUnit/JaCoCo/GitLab 增量覆盖率基础设施，不补存量业务单测；readiness 通过后才允许显式开启。开启后在 ANALYSIS → IMPLEMENT 冻结开关、baseline 与阈值，只验收本任务新增/修改生产代码行，执行 RED/GREEN/REFACTOR（纯重构使用 characterization GREEN → GREEN），并要求本地单测通过、本地差异覆盖率达到冻结阈值。GitLab TEST-stage job 仍会生成，但远程 pipeline 结果不属于 Harness 验收证据，也不会触发中间提交推送。关闭时普通任务不扫描 CI/JaCoCo、不增加命令或提高原工作流验收深度。
 - 所有新代码任务都完整进入 REVIEW；不同工作流模式只调整各状态内部的上下文加载、执行主体、审查独立性、验证范围和记忆深度，不绕过状态或证据门禁。
 - 显式 `doc` / `analysis` / `report` 只读任务不生成 `test-strategy.md`；展示完整报告后按生效模式进入 COMPLETE，不执行 REVIEW、VERIFICATION 或 MEMORY，也不写任务记忆。
 - `VERIFICATION` 是验证硬门控：Fast 运行最小充分检查，Standard 运行受影响范围检查，
@@ -190,7 +193,10 @@ easy-coding upgrade
 项目 Harness 与 CLI 版本完全一致，否则先执行 `easy-coding upgrade` 或更新 CLI）；当前
 session 临时覆盖统一通过 `ec-config` 对话修改。升级到 0.10.0-beta.2 时配置 schema 升至
 5；未完成 `ec-tdd-init` readiness 的项目/session TDD 请求迁移为关闭并保留阈值，同时
-部署共享 Java 差异覆盖率与 readiness 工具。已经冻结的活动任务合同不会被静默改写。
+部署共享 Java 差异覆盖率与 readiness 工具。0.10.0-beta.3 起，TDD 业务任务只依赖本地
+单测与本地差异覆盖率，历史远程 CI 证据保留但不再参与验收。已经冻结的活动任务合同
+不会被静默改写。0.10.0-beta.4 起，仍停在 ANALYSIS 的旧任务必须补齐决策闭环后才能
+进入 IMPLEMENT；已经进入后续阶段的任务不受影响。
 
 若当前会话不希望 Harness 接管，显式调用 `/ec-no-harness`（Codex 使用
 `$ec-no-harness`）。它只旁路 Easy Coding，不关闭其他 hooks，也不忽略其他 skills；

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-coding-harness",
-  "version": "0.10.0-beta.2",
+  "version": "0.10.0-beta.4",
   "description": "CLI scaffold for installing Easy Coding harness files into agent-native directories.",
   "repository": {
     "type": "git",

package/templates/claude/agents/ec-implementer.md

@@ -16,6 +16,7 @@ complete exactly that unit. Your reply IS the return value, not a message to a h
   file. All context you need is already in the task card.
 - Make no workflow stage-transition decisions. You do not know the state machine exists.
 - Follow the coding rules and architecture context embedded in the card.
+- Treat the task card's `Code Comments` author value and field/member/constant rules as mandatory.
 - Treat acceptance criteria, test points, contracts, and risks in the card as required inputs.
 - Run the exact targeted checks requested by the card and report their real outcome.
 - Preserve each existing file's original encoding; never silently convert.

package/templates/codex/agents/ec-implementer.toml

@@ -15,6 +15,7 @@ Hard constraints:
   the card.
 - Make no workflow stage-transition decisions; you do not know the state machine exists.
 - Follow the coding rules and architecture context embedded in the card.
+- Treat the task card's "Code Comments" author value and field/member/constant rules as mandatory.
 - Treat acceptance criteria, test points, contracts, and risks in the card as required inputs.
 - Run the exact targeted checks requested by the card and report their real outcome.
 - Preserve each existing file's original encoding; never silently convert.

package/templates/common/bundled-skills/ec-init/SKILL.md

@@ -161,7 +161,8 @@ agent must be able to see what was generated and on what evidence.
    you verified exist (read package.json scripts or equivalent — do not guess).
    If effective TDD is disabled, do not inspect JaCoCo or GitLab and do not add TDD-specific
    requirements. If it is enabled for Java, additionally document JUnit/JaCoCo commands,
-   production/test source roots, XML report paths, and the existing GitLab TEST-stage gate.
+   production/test source roots, XML report paths, the local acceptance gate, and the generated
+   GitLab TEST-stage job as non-blocking automation infrastructure.
 5. **Memory migration probe** — Check for old-format memory files:
    - `.easy-coding/memory/long/MEMORY.md` exists but lacks `memory_schema: 2` frontmatter
    - `.easy-coding/memory/long/BUSINESS.md` or `TECHNICAL.md` missing

package/templates/common/bundled-skills/ec-meta/references/local-architecture/README.md

@@ -58,8 +58,9 @@ and config fingerprints, and MEMORY keeps the conditional long-memory threshold
 Java TDD is a third independent, default-off control managed by `ec-config`. Session overrides
 project configuration; ANALYSIS freezes enabled state and the 1..100 changed-line threshold
 (default 90) on entry to IMPLEMENT. Disabled TDD changes no ordinary workflow test depth. Enabled
-TDD adds lifecycle evidence, a TDD review dimension, and the same JaCoCo diff gate locally and in
-GitLab TEST-stage CI.
+TDD adds lifecycle evidence, a TDD review dimension, passed local unit-test evidence, and a local
+JaCoCo diff gate. `ec-tdd-init` still generates the equivalent GitLab TEST-stage job, but remote
+pipeline execution and status are not Harness acceptance dependencies.
 
 The active task pointer lives in `sessions/{agent}-{session-id}.json` (with an agent-prefixed PPID fallback only
 when a hook payload has no logical session ID);

package/templates/common/skills/ec-analysis/SKILL.md

@@ -42,7 +42,28 @@ read. `scope-drifted` requires current-code conflict analysis before confirmatio
 ## Analysis artifacts
 
 Copy `.easy-coding/templates/dev-spec-skeleton.md` first, then replace every `[[EC_TODO:...]]`.
-Keep every mandatory section. `### Workflow Mode` is required.
+Keep every mandatory section. The `### 决策闭环` (Decision Closure) and `### Workflow Mode`
+sections are required. The decision section must contain exactly one standalone
+`decision_status: closed` marker, and no other `decision_status` marker may appear elsewhere in
+the document. Record every material question and its resolved conclusion in that section, or
+record that no extra decision was needed.
+
+## Decision closure before implementation
+
+Treat uncertainty that can change the technical route, public or internal contract, data model,
+state flow, edit scope, compatibility behavior, or acceptance criteria as a material open
+question. While any such question remains:
+
+1. stay in ANALYSIS and ask the user focused questions, preferably one decision at a time;
+2. do not present a final analysis summary, propose the final Workflow Mode, request
+   ANALYSIS -> IMPLEMENT, or suggest that implementation can begin;
+3. update the Dev-Spec with each confirmed answer and its evidence;
+4. use `decision_status: open` while the artifact is still being developed, then replace it with
+   the single `decision_status: closed` marker only after every material question is resolved.
+
+Risks, integration work that is intentionally deferred by a frozen Spec, and environmental
+verification limits are not automatically open questions. Describe them as risks or explicit
+acceptance boundaries. Never use `closed` to hide a decision that still needs the user.
 
 Execution plan records use:
 
@@ -113,20 +134,24 @@ When TDD is enabled for a Java code task, make `test-strategy.md` record:
   toward 100% while treating the threshold as the mechanical minimum;
 - feature/bug RED -> GREEN -> REFACTOR evidence, or for pure refactors a pre-change
   characterization GREEN -> post-change GREEN sequence without inventing a RED failure;
-- `.gitlab-ci.yml` and included configuration, the TEST-stage job, JUnit/JaCoCo artifacts, and an
-  equivalent changed-line gate. Reuse a gate only when its threshold is at least the configured
-  value; otherwise include the CI change in the confirmed implementation scope.
+- the local unit-test command and local changed-line acceptance command. Record that
+  `ec-tdd-init` generated the GitLab TEST-stage job, but remote execution, pipeline identity, and
+  status are non-blocking and never require an intermediate commit or push. Include these exact,
+  language-independent contract markers: `local_test_gate: required` and
+  `remote_ci_acceptance: non-blocking`.
 - current `tdd_readiness_status=ready`; if missing or drifted, stop before IMPLEMENT and route to
   `ec-tdd-init`. Never plan to initialize CI inside an already-enabled TDD feature task.
 
 The state API mechanically freezes current Git `HEAD` per repository into `task.tdd_baselines`
-when ANALYSIS advances to IMPLEMENT. Plan both local and GitLab commands with that exact SHA and
-the frozen threshold; never use a mutable `HEAD` fallback at verification time. Non-Canonical TDD
-is limited to one Git repository; multi-repository TDD must use Canonical repository bindings.
+when ANALYSIS advances to IMPLEMENT. Plan the local command with that exact SHA and the frozen
+threshold. The generated GitLab job remains parameterized for infrastructure parity, but the
+Harness acceptance plan never waits for remote CI. Never use a mutable `HEAD` fallback at
+verification time. Non-Canonical TDD is limited to one Git repository; multi-repository TDD must
+use Canonical repository bindings.
 
 Also append a `### TDD Mode` section to `dev-spec.md` with enabled state, frozen threshold,
-baseline, local gate, GitLab TEST gate, and lifecycle evidence. Do not add this section when TDD
-is disabled.
+baseline, local unit-test gate, local coverage gate, generated GitLab job as non-blocking
+infrastructure, and lifecycle evidence. Do not add this section when TDD is disabled.
 
 If the task is not a Java project, explain that Java-only TDD cannot be activated and obtain a
 mode decision before advancing. The CLI never installs JaCoCo or edits CI automatically.
@@ -179,14 +204,22 @@ while still in ANALYSIS.
 
 ## User presentation and transition
 
-Before the boundary, present:
+After decision closure and before the boundary, present a concise session summary instead of
+pasting the full `dev-spec.md`. The summary must contain:
 
-- proposed scope and units;
-- acceptance and test strategy;
+- the core solution and affected scope/units;
+- acceptance and test-strategy highlights;
 - configured, minimum, and selected workflow modes with reasons;
-- how IMPLEMENT, REVIEW, VERIFICATION, and MEMORY will run;
+- the material risks and explicit acceptance boundaries;
 - explicit user ability to request a higher mode or a permitted lower mode.
 
+End the summary with the absolute path to
+`.easy-coding/tasks/<task-id>/dev-spec.md`. When the current client supports local-file Markdown
+links, render `[View full Dev-Spec](</absolute/path/to/dev-spec.md>)`; otherwise print the
+copyable absolute path. Do not dump the full artifact merely because the client cannot link it.
+If the user asks to inspect the full plan, open or read that stored file on demand using the
+current Agent's supported file capability.
+
 Then request or auto-apply ANALYSIS -> IMPLEMENT according to `effective_approval_mode`.
 The state API atomically freezes the proposal when the transition is applied. `approval_mode`
 controls waiting; it never changes the selected execution depth.
@@ -197,6 +230,8 @@ controls waiting; it never changes the selected execution depth.
 - No unresolved skeleton placeholders.
 - No code task with an empty change scope.
 - No unit without acceptance criteria, test points, contracts, and risks.
+- No final summary, workflow proposal, or transition while a material decision is unresolved.
+- No transition without exactly one `decision_status: closed` marker in `dev-spec.md`.
 - No transition without a valid workflow proposal.
 - No Canonical-backed transition with changed source SHA, unresolved repository identity,
   incomplete selected-task coverage, or an open Unit/Step/File/Symbol/Test traceability gap.

package/templates/common/skills/ec-config/SKILL.md

@@ -60,7 +60,9 @@ After explicit user selection, use the current logical session file:
 Turning TDD off must preserve the existing Fast/Standard/Strict test depth exactly: do not inspect
 CI, request JaCoCo, add TDD artifacts, run coverage commands, or strengthen acceptance criteria.
 When TDD is on, explain that it applies only to Java code tasks and activates RED/GREEN/REFACTOR,
-TDD review, local changed-line JaCoCo coverage, and GitLab TEST-stage gate planning.
+TDD review, a passed local unit-test gate, and local changed-line JaCoCo coverage. `ec-tdd-init`
+still generates the GitLab TEST-stage job, but Harness does not wait for or record remote pipeline
+results as acceptance evidence.
 
 Before any project/session enable action, require `tdd_readiness_status=ready`. If it is not ready,
 offer only `ec-tdd-init` or cancellation; never offer or persist "enable now, initialize later".

package/templates/common/skills/ec-implementing/SKILL.md

@@ -36,6 +36,17 @@ Communicate with the user in the user's language.
    enters REVIEW.
 7. Read-only `doc` / `analysis` / `report` tasks remain `single` with `files:[]`, make no writes,
    return a non-empty `deliverable`, then follow the mode-aware IMPLEMENT -> COMPLETE edge.
+8. When a project template, local convention, or new source header uses author attribution, the
+   author value must be `<Current Agent Name> with Easy Coding`, for example
+   `Codex with Easy Coding`. `Current Agent Name` means the user-facing host Agent (for example,
+   Codex, Claude, or Qoder), never an implementation sub-agent role such as `ec-implementer`.
+   Never copy a previous human or Agent name into newly authored code.
+9. Every newly added field in a data-bearing model must have a meaningful field-level comment.
+   This includes new or extended entity/DO/DTO/VO/BO, request/response, configuration, and similar
+   model types. Every new enum member and every new declared constant requires the same treatment.
+   Describe the semantic meaning and, when relevant, units, format, allowed values, nullability,
+   default behavior, or compatibility constraints. A type-level comment does not replace comments
+   on its fields or members; do not add low-value comments to ordinary local variables.
 
 ## Choose the execution owner
 
@@ -81,6 +92,7 @@ Sub-agents never dispatch other sub-agents or read `.easy-coding` workflow asset
 ## Test Points    {unit.test_points and exact targeted commands}
 ## Contracts      {inputs, outputs, invariants shared with other units}
 ## Risks          {known edge cases and compatibility risks}
+## Code Comments  {resolved host Agent author value; model-field, enum-member, and constant rules}
 ## Coding Rules   {pre-digested RULES sections}
 ## Architecture   {pre-digested ABSTRACT sections}
 ## Output
@@ -92,8 +104,12 @@ deliverable|null, issues:[], needs_attention:[]
 
 1. Append a `dispatch` record before work begins. Canonical-backed records include `repo_id` and
    `source_task_id`; resolve every file relative to `task.repo_paths[repo_id]` before dispatch.
+   Populate `Code Comments` on every code task card with the resolved user-facing host Agent
+   author value and the field/member/constant rules above; sub-agents do not read this Skill.
 2. Execute according to dependency order and selected owner.
 3. Run targeted unit tests and self-audit scope, contracts, TODOs, and introduced warnings.
+   Also audit new author attributions and every new model field, enum member, and constant against
+   the comment requirements above before recording success.
 4. Append one `result` record. Only a successful unit uses `status:"completed"`; include
    unresolved issues rather than hiding them, and do not advance while `issues` or
    `needs_attention` is non-empty.
@@ -119,4 +135,6 @@ conversation overhead while keeping work observable.
 - [ ] Every unit has a dispatch/result pair and satisfied its acceptance criteria.
 - [ ] Targeted tests ran or a concrete blocker is recorded.
 - [ ] Cross-unit contracts still match.
+- [ ] New author attributions use the user-facing host `<Current Agent Name> with Easy Coding`.
+- [ ] Every new model field, enum member, and constant has a meaningful field-level comment.
 - [ ] Code tasks enter REVIEW, regardless of workflow mode.

package/templates/common/skills/ec-memory/SKILL.md

@@ -28,9 +28,10 @@ Name it `{memory_id}_{YYYYMMDD}_{smart_name}.md` and set
 `.easy-coding/memory/short/`, then register it with
 `memory-short-complete`. Never invent test results or commit hashes.
 
-When frozen TDD is enabled, add its threshold, lifecycle evidence, local changed-line result,
-and remote CI status to the short memory's execution evidence. When TDD is off, omit TDD fields
-entirely so ordinary tasks incur no additional memory work.
+When frozen TDD is enabled, add its threshold, lifecycle evidence, passed local unit-test result,
+and local changed-line result to the short memory's execution evidence. Remote CI status is not
+part of Harness acceptance or task memory. When TDD is off, omit TDD fields entirely so ordinary
+tasks incur no additional memory work.
 
 Ask the state API for `memory-instruction`. Distill only when it returns `action:distill`;
 otherwise record `no-op`. Long memory receives reusable facts only, not file dumps, transient

package/templates/common/skills/ec-reviewing/SKILL.md

@@ -24,8 +24,10 @@ review dimension. A global record without source ownership cannot satisfy the ga
 When frozen TDD is enabled, add a passed review dimension named exactly `tdd` for each source
 task. Review whether RED/GREEN/REFACTOR (or characterization GREEN for pure refactors) is genuine,
 tests exercise changed behavior and boundaries, mocks do not merely mirror implementation, and
-the local/CI changed-line coverage gates share the frozen threshold. When TDD is off, do not add
-this dimension or raise the ordinary review depth.
+the local unit-test command genuinely passes while the changed-line coverage command uses the
+frozen baseline and threshold. Generated CI configuration may be reviewed when it changed, but
+remote CI status is never a review or acceptance dependency. When TDD is off, do not add this
+dimension or raise the ordinary review depth.
 
 ## Depth by workflow mode
 

package/templates/common/skills/ec-tdd-init/SKILL.md

@@ -64,7 +64,9 @@ purpose is to cover unchanged production code.
 
 The reusable GitLab job must consume a baseline SHA and threshold supplied for the future task;
 do not hardcode the initialization commit or the default 90% threshold. The same Python coverage
-tool must be used locally and remotely.
+tool must be usable locally and remotely. This generated job is remote automation infrastructure,
+not a Harness task acceptance dependency: later tasks require local unit-test and coverage
+evidence only, and never wait for a pipeline URL, job identity, or remote success status.
 
 ## Readiness receipt and verification
 

package/templates/common/skills/ec-verification/SKILL.md

@@ -30,8 +30,8 @@ coverage tool, inspect GitLab, or add a coverage record. The explicit `type=tdd-
 infrastructure exception: run its planned build/CI syntax checks and readiness tool, but do not
 measure repository-wide coverage or append TDD coverage evidence for unchanged production code.
 
-When frozen TDD is on, first run the planned Java unit command and generate JaCoCo XML, then run
-the same deterministic gate intended for GitLab:
+When frozen TDD is on, first run the planned local Java unit command and generate JaCoCo XML,
+then run the deterministic local acceptance gate:
 
 ```bash
 python3 .easy-coding/tools/easy_coding_java_coverage.py check \
@@ -43,10 +43,10 @@ The tool measures covered added/modified production Java executable lines only.
 comment, blank, import, and test-source lines are excluded by diff/JaCoCo intersection. Missing
 or ambiguous source files and reports older than their modified source fail; zero modified
 executable lines is explicit N/A. Always regenerate JaCoCo XML after the final source change.
-Record CI as pending until the remote pipeline actually passes; local green is not remote green.
 Never substitute `HEAD`, a mutable ref, project defaults, or current session settings for the
-task-frozen baseline SHA and threshold. GitLab must invoke the tool with the same two frozen
-values; a session override therefore requires the CI command/variable for this task to match it.
+task-frozen baseline SHA and threshold. `ec-tdd-init` still generates a GitLab job that can run
+the same tool, but remote pipeline execution and status are outside Harness acceptance. Never
+request an intermediate commit or push merely to obtain CI evidence.
 
 The main Agent may run commands inline. Dispatch verifier sub-agents only when checks are
 independent and parallel execution materially saves time or isolates specialist environments.
@@ -86,23 +86,11 @@ For TDD coverage, copy the tool output into `coverage`: `baseline_sha`, `covered
 `applicable:false` plus the tool's reason only for zero executable modified lines. A percentage
 below the frozen threshold fails even when ordinary tests pass.
 
-Append two coverage records per repository (and per Canonical source task): one with
-`coverage_scope:"local"`, and one with `coverage_scope:"gitlab"`. The GitLab record may be
-appended only after the remote job succeeds and must also include:
-
-```json
-{
-  "ci": {
-    "provider": "gitlab",
-    "pipeline_url": "https://gitlab.example/.../pipelines/123",
-    "job_name": "changed-line-coverage",
-    "status": "success"
-  }
-}
-```
-
-Both records must preserve the same task-frozen baseline and threshold. A local-only result,
-pending/failed pipeline, missing job identity, or synthetic remote pass cannot satisfy MEMORY.
+Append one coverage record with `coverage_scope:"local"` per repository (and per Canonical
+source task). The state gate also requires a passed local `check_type:"test"` record for the same
+owner. The coverage record preserves the task-frozen baseline and threshold. Do not append or
+wait for GitLab pipeline evidence; historical remote coverage records are ignored by acceptance
+without modifying or deleting the stored records.
 
 For `type=tdd-init`, the infrastructure receipt must already have been recorded during IMPLEMENT
 and reviewed with the rest of the implementation. Run only `easy_coding_tdd_readiness.py check`

package/templates/main-constraint/AGENTS.md.tpl

@@ -53,8 +53,9 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   there is no enable-now/init-later state. The dedicated `tdd-init` task always freezes TDD off and
   initializes only changed-line coverage infrastructure, never historical business-test coverage.
   Disabled TDD adds no CI scan, JaCoCo work, commands, artifacts, or stronger gates. Enabled TDD
-  applies only to Java code tasks and requires lifecycle, review, local coverage, and GitLab
-  TEST-stage evidence for production lines changed since the task baseline.
+  applies only to Java code tasks and requires lifecycle, review, passed local unit tests, and
+  local coverage for production lines changed since the task baseline. `ec-tdd-init` still
+  generates GitLab TEST-stage automation, but remote CI status is not Harness acceptance evidence.
 - Confirmation-required edges use `pending_transition`; automatic edges use the restricted
   `auto-transition` API. A read-only task creates no test-strategy.md, never enters REVIEW,
   VERIFICATION, or MEMORY, and writes no task memory.
@@ -75,10 +76,14 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   only Easy Coding workflow/stage orchestration for this session. Continue honoring every
   non-Easy-Coding skill, hook, and instruction. Do not clear or mutate the suspended task.
 - ANALYSIS must follow template-first: read `.easy-coding/templates/dev-spec-skeleton.md` then
-  write its exact content to the task's dev-spec.md as the FIRST tool calls. Next inspect evidence
-  without editing the skeleton, ask every unresolved decision during analysis, and wait. Only
-  after all decisions are resolved may the agent fill the complete dev-spec.md. The final report
-  contains neither `[阶段：ANALYSIS]` nor a `待用户决策` section.
+  write its exact content to the task's dev-spec.md as the FIRST tool calls. Next inspect evidence,
+  set `decision_status: open`, ask every unresolved material decision, and progressively record
+  each confirmed answer and its evidence in `### 决策闭环`. Only after all material decisions are
+  resolved may the agent set the single `decision_status: closed`, finalize the artifacts, and
+  propose IMPLEMENT. The session presentation is a concise core-solution, acceptance, workflow,
+  and risk summary with an absolute local link/path to the full dev-spec.md; never paste the full
+  artifact by default. The final artifact contains neither `[阶段：ANALYSIS]` nor a
+  `待用户决策` section.
 - REVIEW and VERIFICATION are fingerprinted hard gates. Review evidence must match the final
   implementation; verification evidence must match final implementation and config. The frozen
   workflow mode selects targeted, impacted, or full commands without weakening the green gate.

package/templates/main-constraint/CLAUDE.md.tpl

@@ -51,8 +51,9 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   there is no enable-now/init-later state. The dedicated `tdd-init` task always freezes TDD off and
   initializes only changed-line coverage infrastructure, never historical business-test coverage.
   Disabled TDD adds no CI scan, JaCoCo work, commands, artifacts, or stronger gates. Enabled TDD
-  applies only to Java code tasks and requires lifecycle, review, local coverage, and GitLab
-  TEST-stage evidence for production lines changed since the task baseline.
+  applies only to Java code tasks and requires lifecycle, review, passed local unit tests, and
+  local coverage for production lines changed since the task baseline. `ec-tdd-init` still
+  generates GitLab TEST-stage automation, but remote CI status is not Harness acceptance evidence.
 - Confirmation-required edges use `pending_transition`; automatic edges use the restricted
   `auto-transition` API. A read-only task creates no test-strategy.md, never enters REVIEW,
   VERIFICATION, or MEMORY, and writes no task memory.
@@ -73,10 +74,14 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   only Easy Coding workflow/stage orchestration for this session. Continue honoring every
   non-Easy-Coding skill, hook, and instruction. Do not clear or mutate the suspended task.
 - ANALYSIS must follow template-first: read `.easy-coding/templates/dev-spec-skeleton.md` then
-  write its exact content to the task's dev-spec.md as the FIRST tool calls. Next inspect evidence
-  without editing the skeleton, ask every unresolved decision during analysis, and wait. Only
-  after all decisions are resolved may the agent fill the complete dev-spec.md. The final report
-  contains neither `[阶段：ANALYSIS]` nor a `待用户决策` section.
+  write its exact content to the task's dev-spec.md as the FIRST tool calls. Next inspect evidence,
+  set `decision_status: open`, ask every unresolved material decision, and progressively record
+  each confirmed answer and its evidence in `### 决策闭环`. Only after all material decisions are
+  resolved may the agent set the single `decision_status: closed`, finalize the artifacts, and
+  propose IMPLEMENT. The session presentation is a concise core-solution, acceptance, workflow,
+  and risk summary with an absolute local link/path to the full dev-spec.md; never paste the full
+  artifact by default. The final artifact contains neither `[阶段：ANALYSIS]` nor a
+  `待用户决策` section.
 - REVIEW and VERIFICATION are fingerprinted hard gates. Review evidence must match the final
   implementation; verification evidence must match final implementation and config. The frozen
   workflow mode selects targeted, impacted, or full commands without weakening the green gate.

package/templates/qoder/agents/ec-implementer.md

@@ -18,6 +18,7 @@ complete exactly that unit. Your reply IS the return value, not a message to a h
   context is in the card.
 - Make no workflow stage-transition decisions; you do not know the state machine exists.
 - Follow the coding rules and architecture context embedded in the card.
+- Treat the task card's `Code Comments` author value and field/member/constant rules as mandatory.
 - Treat acceptance criteria, test points, contracts, and risks in the card as required inputs.
 - Run the exact targeted checks requested by the card and report their real outcome.
 - Preserve each existing file's original encoding; never silently convert.

package/templates/runtime/templates/dev-spec-skeleton.md

@@ -24,6 +24,11 @@
 - 需求 vs 现有代码：[[EC_TODO:填写结果或“无冲突”]]
 - Dev-Spec vs 现有代码：[[EC_TODO:填写结果或“无冲突”]]
 
+### 决策闭环
+decision_status: [[EC_TODO:仅当所有实质性问题均已解决并回填后写 closed]]
+- **已解决问题与结论**：[[EC_TODO:逐项记录影响技术路线、接口、模型、状态、范围或验收的问题及最终结论；无则写“无”]]
+- **确认依据**：[[EC_TODO:用户答复、冻结 Spec、现有代码证据或“无额外决策”]]
+
 ### Canonical Spec 来源
 - **来源**：[[EC_TODO:非 Canonical 任务写“无”；否则填写 repo-relative path、spec_id、revision、SHA-256]]
 - **选择任务 / 仓库**：[[EC_TODO:非 Canonical 任务写“无”；否则填写 selected task IDs 与 repo IDs]]

package/templates/shared-hooks/easy_coding_state.py

@@ -38,6 +38,7 @@ MANDATORY_DEV_SPEC_HEADERS: list[str] = [
     "### 需求解析",
     "### 现状",
     "### 冲突摘要",
+    "### 决策闭环",
     "### 影响面分析",
     "### 改动范围",
     "### 修改方案",
@@ -117,6 +118,19 @@ SHORT_MEMORY_UUID_V7_PATTERN = re.compile(
 )
 LEGACY_SHORT_MEMORY_ID_PATTERN = re.compile(r"^SM-\d{8}-\d+$")
 DEV_SPEC_PLACEHOLDER_PATTERN = re.compile(r"\[\[EC_TODO:[^\]\n]+\]\]")
+DECISION_STATUS_PATTERN = re.compile(
+    r"\s*decision_status\s*:\s*([a-z][a-z0-9_-]*)\s*", re.IGNORECASE
+)
+DECISION_CONCLUSIONS_PATTERN = re.compile(
+    r"\s*(?:[-+*]\s+)?(?:\*\*)?已解决问题与结论(?:\*\*)?\s*[:：]\s*(.+?)\s*"
+)
+DECISION_EVIDENCE_PATTERN = re.compile(
+    r"\s*(?:[-+*]\s+)?(?:\*\*)?确认依据(?:\*\*)?\s*[:：]\s*(.+?)\s*"
+)
+UNRESOLVED_DECISION_VALUE_PATTERN = re.compile(
+    r"(?:待确认|待决策|未确认|未决|todo|tbd|unknown|open|pending|unresolved)[。.!！]?",
+    re.IGNORECASE,
+)
 MARKDOWN_HEADING_PATTERN = re.compile(r"^(#{1,6})\s+(.+?)\s*$")
 TABLE_HEADER_CELLS = {
     "改动文件",
@@ -2526,6 +2540,13 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
             and record.get("config_fingerprint") == fingerprints["config_fingerprint"]
             and is_non_empty_string(record.get("check"))
         ):
+            if (
+                task.get("tdd_enabled") is True
+                and record.get("check_type") == "coverage"
+                and record.get("coverage_scope") == "gitlab"
+            ):
+                # 远程 CI 只作为生成的自动化能力，历史 pending/failed 记录不再参与本地验收。
+                continue
             check = str(record["check"])
             if task.get("tdd_enabled") is True and record.get("check_type") == "coverage":
                 check = f"{check}\0{record.get('coverage_scope') or ''}"
@@ -2608,6 +2629,12 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
         )
     if task.get("tdd_enabled") is True:
         require_tdd_readiness(root)
+        test_records = [
+            record
+            for record in latest_by_check.values()
+            if record.get("check_type") == "test"
+            and record.get("applicable") is not False
+        ]
         coverage_records = [
             record
             for record in latest_by_check.values()
@@ -2618,6 +2645,17 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
                 "TDD verification requires changed-production-line JaCoCo coverage evidence."
             )
         if is_spec_task:
+            tested_source_tasks = {
+                str(record.get("source_task_id") or "") for record in test_records
+            }
+            missing_test_tasks = sorted(
+                set(task_repositories) - tested_source_tasks
+            )
+            if missing_test_tasks:
+                raise StateError(
+                    "TDD Canonical verification requires local unit-test evidence for every selected source task: "
+                    + ", ".join(missing_test_tasks)
+                )
             covered_source_tasks = {
                 str(record.get("source_task_id") or "") for record in coverage_records
             }
@@ -2629,19 +2667,16 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
                     "TDD Canonical verification requires separate coverage evidence for every selected source task: "
                     + ", ".join(missing_coverage_tasks)
                 )
-        coverage_scopes_by_owner: dict[str, set[str]] = {}
+        elif not test_records:
+            raise StateError(
+                "TDD verification requires passed local unit-test evidence."
+            )
         for record in coverage_records:
             scope = str(record.get("coverage_scope") or "")
-            if scope not in {"local", "gitlab"}:
+            if scope != "local":
                 raise StateError(
-                    "TDD coverage evidence must identify coverage_scope as local or gitlab."
+                    "TDD coverage evidence must identify coverage_scope as local."
                 )
-            owner = (
-                str(record.get("source_task_id") or "")
-                if is_spec_task
-                else "project"
-            )
-            coverage_scopes_by_owner.setdefault(owner, set()).add(scope)
         expected_threshold = task.get("tdd_coverage_threshold")
         expected_baselines = task.get("tdd_baselines")
         if (
@@ -2656,18 +2691,6 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
             coverage = record.get("coverage")
             if not isinstance(coverage, dict):
                 raise StateError("TDD coverage evidence must include the coverage result object.")
-            if record.get("coverage_scope") == "gitlab":
-                ci = record.get("ci")
-                if (
-                    not isinstance(ci, dict)
-                    or ci.get("provider") != "gitlab"
-                    or ci.get("status") != "success"
-                    or not is_non_empty_string(ci.get("pipeline_url"))
-                    or not is_non_empty_string(ci.get("job_name"))
-                ):
-                    raise StateError(
-                        "GitLab coverage evidence requires a successful pipeline URL and job name."
-                    )
             total = coverage.get("total_lines")
             covered = coverage.get("covered_lines")
             percentage = coverage.get("percentage")
@@ -2722,18 +2745,6 @@ def validate_verification_readiness(root: Path, task_id: str, task: dict) -> Non
                 raise StateError(
                     f"TDD changed-line coverage must meet the frozen {threshold}% threshold."
                 )
-        expected_coverage_owners = set(task_repositories) if is_spec_task else {"project"}
-        missing_scopes = [
-            f"{owner}:{scope}"
-            for owner in sorted(expected_coverage_owners)
-            for scope in ("local", "gitlab")
-            if scope not in coverage_scopes_by_owner.get(owner, set())
-        ]
-        if missing_scopes:
-            raise StateError(
-                "TDD verification requires both local and successful GitLab coverage gates: "
-                + ", ".join(missing_scopes)
-            )
     if task.get("workflow_mode") == "strict":
         if is_spec_task:
             check_types_by_repository: dict[str, set[str]] = {
@@ -2913,19 +2924,35 @@ def validate_read_only_completion(root: Path, task_id: str) -> None:
         )
 
 
+def markdown_fence_token(line: str) -> tuple[str, int, str] | None:
+    stripped = line.lstrip()
+    if not stripped or stripped[0] not in {"`", "~"}:
+        return None
+    marker = stripped[0]
+    run_length = len(stripped) - len(stripped.lstrip(marker))
+    if run_length < 3:
+        return None
+    return marker, run_length, stripped[run_length:]
+
+
 def markdown_headings(content: str) -> list[tuple[int, int, str]]:
     headings: list[tuple[int, int, str]] = []
-    fence_marker: str | None = None
+    fence_marker: tuple[str, int] | None = None
     for index, line in enumerate(content.splitlines()):
-        stripped = line.lstrip()
-        if stripped.startswith(("```", "~~~")):
-            marker = stripped[:3]
-            if fence_marker is None:
-                fence_marker = marker
-            elif fence_marker == marker:
+        fence = markdown_fence_token(line)
+        if fence_marker is not None:
+            marker, run_length, remainder = fence or ("", 0, "")
+            if (
+                marker == fence_marker[0]
+                and run_length >= fence_marker[1]
+                and not remainder.strip()
+            ):
                 fence_marker = None
             continue
-        if fence_marker is not None:
+        if fence is not None:
+            marker, run_length, remainder = fence
+            if marker != "`" or "`" not in remainder:
+                fence_marker = (marker, run_length)
             continue
         match = MARKDOWN_HEADING_PATTERN.match(line.strip())
         if match:
@@ -2933,6 +2960,55 @@ def markdown_headings(content: str) -> list[tuple[int, int, str]]:
     return headings
 
 
+def markdown_section_body(content: str, title: str, level: int = 3) -> str | None:
+    lines = content.splitlines()
+    headings = markdown_headings(content)
+    heading_index = next(
+        (
+            index
+            for index, (_, heading_level, heading_title) in enumerate(headings)
+            if heading_level == level and heading_title == title
+        ),
+        None,
+    )
+    if heading_index is None:
+        return None
+    line_index, heading_level, _ = headings[heading_index]
+    next_line_index = len(lines)
+    for candidate_line, candidate_level, _ in headings[heading_index + 1 :]:
+        if candidate_level <= heading_level:
+            next_line_index = candidate_line
+            break
+    return "\n".join(lines[line_index + 1 : next_line_index])
+
+
+def markdown_standalone_field_values(content: str, pattern: re.Pattern[str]) -> list[str]:
+    values: list[str] = []
+    fence_marker: tuple[str, int] | None = None
+    for line in content.splitlines():
+        fence = markdown_fence_token(line)
+        if fence_marker is not None:
+            marker, run_length, remainder = fence or ("", 0, "")
+            if (
+                marker == fence_marker[0]
+                and run_length >= fence_marker[1]
+                and not remainder.strip()
+            ):
+                fence_marker = None
+            continue
+        if fence is not None:
+            marker, run_length, remainder = fence
+            if marker != "`" or "`" not in remainder:
+                fence_marker = (marker, run_length)
+            continue
+        if line.startswith(("\t", "    ")):
+            continue
+        match = pattern.fullmatch(line)
+        if match:
+            values.append(match.group(1).strip())
+    return values
+
+
 def has_meaningful_markdown_body(content: str) -> bool:
     for line in content.splitlines():
         stripped = line.strip()
@@ -3049,6 +3125,71 @@ def validate_analysis_readiness(
         if "[阶段：ANALYSIS]" in dev_spec_content or "### 待用户决策" in dev_spec_content:
             reasons.append("dev-spec.md contains forbidden analysis-only sections")
 
+        decision_headings = [
+            heading
+            for heading in markdown_headings(dev_spec_content)
+            if heading[1] == 3 and heading[2] == "决策闭环"
+        ]
+        if len(decision_headings) != 1:
+            reasons.append(
+                "dev-spec.md must contain exactly one `### 决策闭环` section; "
+                f"found {len(decision_headings)}"
+            )
+        decision_section = markdown_section_body(dev_spec_content, "决策闭环") or ""
+        all_decision_statuses = [
+            value.lower()
+            for value in markdown_standalone_field_values(
+                dev_spec_content, DECISION_STATUS_PATTERN
+            )
+        ]
+        section_decision_statuses = [
+            value.lower()
+            for value in markdown_standalone_field_values(
+                decision_section, DECISION_STATUS_PATTERN
+            )
+        ]
+        if not all_decision_statuses:
+            reasons.append(
+                "dev-spec.md is missing the decision closure marker `decision_status: closed`; "
+                "resume ec-analysis, resolve material questions, and record the conclusions first"
+            )
+        elif len(all_decision_statuses) != 1:
+            reasons.append(
+                "dev-spec.md must contain exactly one decision_status marker; "
+                f"found {len(all_decision_statuses)}"
+            )
+        elif len(section_decision_statuses) != 1:
+            reasons.append(
+                "dev-spec.md decision_status marker must be inside the `### 决策闭环` section"
+            )
+        elif section_decision_statuses[0] != "closed":
+            reasons.append(
+                "dev-spec.md has unresolved material decisions: "
+                f"decision_status is {section_decision_statuses[0]!r}, expected 'closed'"
+            )
+        decision_conclusions = markdown_standalone_field_values(
+            decision_section, DECISION_CONCLUSIONS_PATTERN
+        )
+        decision_evidence = markdown_standalone_field_values(
+            decision_section, DECISION_EVIDENCE_PATTERN
+        )
+        for field_name, values in (
+            ("已解决问题与结论", decision_conclusions),
+            ("确认依据", decision_evidence),
+        ):
+            if len(values) != 1:
+                reasons.append(
+                    "dev-spec.md decision closure must contain exactly one non-empty "
+                    f"`{field_name}` field; found {len(values)}"
+                )
+            elif UNRESOLVED_DECISION_VALUE_PATTERN.fullmatch(
+                re.sub(r"[`*_]", "", values[0]).strip()
+            ):
+                reasons.append(
+                    "dev-spec.md has unresolved decision closure evidence: "
+                    f"`{field_name}` is {values[0]!r}"
+                )
+
         if not skeleton.exists():
             reasons.append("dev-spec skeleton template is missing")
         else:
@@ -3098,7 +3239,13 @@ def validate_analysis_readiness(
             strategy_content = test_strategy.read_text(encoding="utf-8")
         except OSError:
             strategy_content = ""
-        required_tdd_markers = ["TDD", "JaCoCo", "baseline", "GitLab"]
+        required_tdd_markers = [
+            "TDD",
+            "JaCoCo",
+            "baseline",
+            "local_test_gate: required",
+            "remote_ci_acceptance: non-blocking",
+        ]
         missing_tdd_markers = [
             marker for marker in required_tdd_markers if marker.lower() not in strategy_content.lower()
         ]