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

package/CHANGELOG.md

@@ -6,6 +6,18 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 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,7 @@ 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、不增加命令或提高原工作流验收深度。
+- 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 +190,9 @@ 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 证据保留但不再参与验收。已经冻结的活动任务合同
+不会被静默改写。
 
 若当前会话不希望 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.3",
   "description": "CLI scaffold for installing Easy Coding harness files into agent-native directories.",
   "repository": {
     "type": "git",

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

@@ -113,20 +113,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.

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-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.

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.

package/templates/shared-hooks/easy_coding_state.py

@@ -2526,6 +2526,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 +2615,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 +2631,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 +2653,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 +2677,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 +2731,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]] = {
@@ -3098,7 +3095,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()
         ]