easy-coding-harness 1.1.0-beta.3 → 1.1.0-beta.4

package/CHANGELOG.md

@@ -6,6 +6,15 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 1.1.0-beta.4
+
+- Hook 使用独立的会话存储与状态展示模块，避免加载完整工作流和 Canonical Spec 校验器；
+  同次调用复用配置、任务与执行日志读取，保留会话迁移及状态提示。
+- 定向检查区分生产依赖、选中测试与公共辅助输入，保留构建所需依赖，减少无关测试变化导致的重跑。
+- 验收快照复用未变 Git 对象，只读取变化内容；自动验收共享本次漂移结果，保留全仓变化检测。
+- Canonical 写回复用同次前置检查与写后确认，保留设计新鲜度、CAS 和幂等语义；批量准备、
+  登记检查作为默认调用方式，减少重复状态查询。
+
 ## 1.1.0-beta.3
 
 - MEMORY 以可复用开发知识为正文，提炼业务规则、设计原因、修改入口、适用边界与真实踩坑经验；

package/package.json

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

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

@@ -208,7 +208,11 @@ Acceptance: <observable outcome and minimum check>
 Record Unit `input_files` for the known additional direct inputs (an empty list means the
 Unit files are self-contained). Include shared helpers, fixtures, schemas and configuration
 actually consumed by its checks. Without a declared closure, checks cover the owning module.
-Build commands still include their module compilation inputs. Do not infer a whole-program call graph. Keep Unit contracts and test points in the existing execution plan. Do not duplicate them across
+For targeted Vitest/Jest/Python/Node checks, name the selected test file in the command and declare
+its helper/fixture inputs so unrelated test cases can retain their evidence. Module production
+inputs and build configuration remain included. Maven/Gradle/tsc compilation still includes
+neighboring sources/tests even with a test selector. Do not infer a whole-program call graph.
+Keep Unit contracts and test points in the existing execution plan. Do not duplicate them across
 full template chapters or create a separate test strategy for this compact form. Canonical work
 consumes the selected source closure; it does not redesign unrelated selected tasks.
 

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

@@ -37,6 +37,9 @@ tracking metadata is handled once; do not reopen design or rewrite the complete
 
 When a lifecycle check is necessary, call `prepare-check` before running it and `record-check`
 afterward as documented in ec-quality. QUALITY reuses these input-bound results.
+Batch independent checks at the same code state with the array forms of `--record` and `--result`.
+Use each state operation's returned context and next action; query again only when required
+information is absent or an intervening edit makes the returned context stale.
 
 ## Non-negotiable gates
 

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

@@ -22,24 +22,27 @@ Call `evidence-fingerprints` once to obtain the runtime-owned attempt and candid
 owns signatures and prior-evidence references. Never calculate historical fingerprints, import
 runtime internals to reconstruct old candidates, or ask a reviewer to audit workflow bookkeeping.
 
-For each distinct review or verification, prepare its actual inputs before executing it:
+Prepare independent checks for the same unchanged candidate in one batch before executing them:
 
 ```bash
 {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py prepare-check \
-  --record '<review/verify JSON with unit_id, dimension or check/check_type/command>' \
+  --record '[<review/verify JSON with unit_id, dimension or check/check_type/command>, ...]' \
   --agent <agent-id> --session-file <P>
 ```
 
-When `reusable:true`, use the returned evidence index and skip that check. Otherwise run the
-specified check once, then register its real result:
+For each returned item with `reusable:true`, use its evidence index and skip that check. Run the
+remaining checks once, then register their real results in one batch:
 
 ```bash
 {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py record-check \
-  --prepared-id <returned-id> --result '<JSON with passed, exit_code for verification, findings/reviewer for review>' \
+  --result '[{"prepared_id":"<returned-id>","result":<JSON with passed, exit_code for verification, findings/reviewer for review>}, ...]' \
   --agent <agent-id> --session-file <P>
 ```
 
 Preparation binds code/test inputs, module dependencies, build files and the actual command.
+Batching preserves each check's result and evidence identity. A single check may still use
+`--prepared-id` with one result object. Start a new preparation batch after a code change;
+never reuse a pre-edit input snapshot for post-edit checks.
 Use the analyzed Unit `input_files` closure for additional helpers/fixtures/configuration, and record intentional
 environment overrides in the check descriptor. Production-only reviews may declare
 `review_scope:"production"`; test review still covers changed test behavior. A result is accepted
@@ -185,9 +188,9 @@ This returns other-Agent repairs to the coordinator for delta review/verificatio
 may pass while the repair is pending. Scope/contract changes must be resolved rather than silently
 included in the accepted bundle. Repeated starts/completions reuse the existing repair ID.
 
-`prepare-check --record` also accepts an array. `record-check --result` accepts an array of
-`{prepared_id,result}` to register the results of those prepared checks. Each check keeps its own
-inputs and real result; batching shares runtime reads, not unrelated evidence.
+Use the same batch prepare/record flow for repair checks. Consume returned state and next-action
+fields directly; do not follow a successful state operation with an unchanged `snapshot` or
+Spec inspection merely to retrieve fields already returned.
 
 After repair, choose the minimum honest evidence refresh:
 

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

@@ -57,6 +57,9 @@ or `qoder`. Never use a display or source-author attribution such as `Codex with
 
 1. Read the injected state breadcrumbs or call:
 
+   Prefer the injected or most recent operation's state. Call `snapshot` only when that context
+   is missing or stale; do not repeat it after a successful operation that already returns state.
+
    ```bash
    {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py snapshot --agent <agent-id> --session-file <P>
    ```

package/templates/shared-hooks/easy_coding_inputs.py

@@ -10,47 +10,16 @@ import stat
 import subprocess
 import sys
 import xml.etree.ElementTree as ET
-from contextlib import contextmanager
-from contextvars import ContextVar
+from easy_coding_operation import evidence_operation, memo, cached_memo, invalidate_memo
 from pathlib import Path
 
 
-_operation = ContextVar("evidence_operation", default=None)
 BUILD_FILES = ("pom.xml", "package.json", "package-lock.json", "pnpm-lock.yaml",
                "yarn.lock", "tsconfig.json", "build.gradle", "build.gradle.kts",
                "settings.gradle", "gradle.properties", ".gitattributes", ".npmrc",
                "vitest.config.ts", "jest.config.js", "biome.json", "pytest.ini", "pyproject.toml")
 
 
-@contextmanager
-def evidence_operation():
-    token = _operation.set({})
-    try:
-        yield
-    finally:
-        _operation.reset(token)
-
-
-def memo(key, compute):
-    cache = _operation.get()
-    if cache is None:
-        return compute()
-    if key not in cache:
-        cache[key] = compute()
-    return cache[key]
-
-
-def invalidate_memo(key):
-    cache = _operation.get()
-    if cache is not None:
-        cache.pop(key, None)
-
-
-def cached_memo(key):
-    cache = _operation.get()
-    return cache.get(key) if cache is not None else None
-
-
 def command_identity(command):
     # Shell 展开和重定向受引号影响；只归一化普通 argv 命令，避免错误复用。
     if re.search(r"[\$`\\\n;|&<>*?\[\]{}~#]", command):
@@ -153,7 +122,7 @@ def is_test(path):
 
 def is_test_case(path):
     name = Path(path).name
-    return bool(re.search(r"(?:Test|Tests|IT)\.java$|\.(?:test|spec)\.[cm]?[jt]sx?$|^test_.*\.py$", name))
+    return bool(re.search(r"(?:Test|Tests|IT)\.java$|\.(?:test|spec)\.[cm]?[jt]sx?$|^test_.*\.py$|_test\.py$", name))
 
 
 def command_tokens(command):
@@ -165,6 +134,36 @@ def command_tokens(command):
     return tokens
 
 
+def targeted_test_files(command):
+    """只识别完整、无 shell 展开的文件选择调用；未知参数保持模块范围。"""
+    if not isinstance(command_identity(command), tuple):
+        return set()
+    tokens = command_tokens(command)
+    if not tokens:
+        return set()
+    if Path(tokens[0]).name == "npx":
+        tokens = tokens[1:]
+    elif tokens[:2] in (["pnpm", "exec"], ["npm", "exec"]):
+        tokens = tokens[2:]
+        if tokens[:1] == ["--"]:
+            tokens = tokens[1:]
+    if not tokens:
+        return set()
+    runner, arguments = Path(tokens[0]).name, tokens[1:]
+    if runner in {"python", "python3"} and arguments[:2] == ["-m", "pytest"]:
+        runner, arguments = "pytest", arguments[2:]
+    if runner == "vitest" and arguments[:1] == ["run"]:
+        arguments = arguments[1:]
+    elif runner == "node" and arguments[:1] == ["--test"]:
+        arguments = arguments[1:]
+    elif runner not in {"jest", "pytest", "python", "python3"}:
+        return set()
+    files = [value for value in arguments if value not in {"-q", "-v", "--runInBand", "--coverage"}]
+    if not files or any(value.startswith("-") or not is_test_case(value) for value in files):
+        return set()
+    return {str(Path(value)) for value in files}
+
+
 def toolchain_identity(command):
     tokens = command_tokens(command)
     executable = tokens[0] if tokens else ""
@@ -220,14 +219,25 @@ def input_spec(root, task, plan, check):
     tokens = command_tokens(command)
     executable = Path(tokens[0]).name if tokens else ""
     builds_module = check.get("type") == "verify" and executable in {
-        "mvn", "mvnw", "gradle", "gradlew", "npm", "npx", "pnpm", "yarn", "tsc"
+        "mvn", "mvnw", "gradle", "gradlew", "npm", "npx", "pnpm", "yarn", "tsc",
+        "vitest", "jest", "pytest", "python", "python3", "node",
     }
+    selected_tests = targeted_test_files(command)
     repositories = {}
+    production_repositories = {}
     for unit in selected:
         repo_id = unit.get("repo_id") or "current"
         base = Path(task.get("repo_paths", {}).get(repo_id, root))
         base = (base if base.is_absolute() else root / base).resolve()
         paths = repositories.setdefault(str(base), set())
+        # 只有明确文件选择器和已声明依赖闭包的脚本测试才收窄测试输入。
+        # Maven/Gradle/tsc 的编译阶段仍消费模块内源文件，不能按测试名称裁剪。
+        test_files = {str(Path(name)) for name in [*unit.get("files", []), *unit.get("input_files", [])]
+                      if is_test_case(name)}
+        targeted_script = (
+            check.get("type") == "verify" and "input_files" in unit
+            and bool(selected_tests) and selected_tests <= test_files
+        )
         for name in [*unit.get("files", []), *unit.get("input_files", [])]:
             absolute = Path(name) if Path(name).is_absolute() else base / name
             relative = absolute.relative_to(base).as_posix()
@@ -261,16 +271,18 @@ def input_spec(root, task, plan, check):
                             pending.append(candidate)
             for module in involved:
                 for folder in ("src/main", "src" if not (module / "pom.xml").exists() else "src/test"):
-                    if (builds_module or "input_files" not in unit) and (module / folder).is_dir():
-                        paths.add((module / folder).relative_to(base).as_posix())
+                    if (builds_module or targeted_script or "input_files" not in unit) and (module / folder).is_dir():
+                        destination = (production_repositories.setdefault(str(base), set())
+                                       if targeted_script else paths)
+                        destination.add((module / folder).relative_to(base).as_posix())
                 for parent in [module, *module.parents]:
                     if not parent.is_relative_to(base):
                         break
                     for filename in BUILD_FILES:
                         if (parent / filename).is_file():
                             paths.add((parent / filename).relative_to(base).as_posix())
-            for config in (".mvn", "gradle", "test" if builds_module else "test/fixtures",
-                           "tests" if builds_module else "tests/fixtures"):
+            for config in (".mvn", "gradle", "test" if builds_module and not targeted_script else "test/fixtures",
+                           "tests" if builds_module and not targeted_script else "tests/fixtures"):
                 if (base / config).is_dir():
                     paths.add(config)
     if task.get("unit_test_mode") in {"ut", "tdd"}:
@@ -284,6 +296,8 @@ def input_spec(root, task, plan, check):
     return {
         "schema": 1,
         "repositories": {r: sorted(paths) for r, paths in sorted(repositories.items())},
+        **({"production_repositories": {r: sorted(paths) for r, paths in sorted(production_repositories.items())}}
+           if production_repositories else {}),
         "production_only": check.get("review_scope") == "production",
         "contract": [{"id": u["id"], "contracts": u.get("contracts", []),
                       "acceptance_criteria": u.get("acceptance_criteria", [])} for u in owners]
@@ -299,6 +313,9 @@ def capture(spec):
     for root, scopes in spec["repositories"].items():
         repository = memo(("repository", root), lambda: RepositoryInputs(Path(root)))
         inputs[root] = repository.capture(scopes, spec["production_only"])
+        production_scopes = spec.get("production_repositories", {}).get(root, [])
+        if production_scopes:
+            inputs[root].update(repository.capture(production_scopes, production_only=True))
     return {"spec": spec, "files": inputs, "signature": digest([spec, inputs])}
 
 

package/templates/shared-hooks/easy_coding_operation.py

@@ -0,0 +1,39 @@
+"""Operation-local caches shared by hooks and state commands."""
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+
+_operation = ContextVar("evidence_operation", default=None)
+
+
+@contextmanager
+def evidence_operation():
+    if _operation.get() is not None:
+        yield
+        return
+    token = _operation.set({})
+    try:
+        yield
+    finally:
+        _operation.reset(token)
+
+
+def memo(key, compute):
+    cache = _operation.get()
+    if cache is None:
+        return compute()
+    if key not in cache:
+        cache[key] = compute()
+    return cache[key]
+
+
+def invalidate_memo(key):
+    cache = _operation.get()
+    if cache is not None:
+        cache.pop(key, None)
+
+
+def cached_memo(key):
+    cache = _operation.get()
+    return cache.get(key) if cache is not None else None