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

package/CHANGELOG.md

@@ -6,6 +6,26 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 1.1.0-beta.4
+
+- Hook 使用独立的会话存储与状态展示模块，避免加载完整工作流和 Canonical Spec 校验器；
+  同次调用复用配置、任务与执行日志读取，保留会话迁移及状态提示。
+- 定向检查区分生产依赖、选中测试与公共辅助输入，保留构建所需依赖，减少无关测试变化导致的重跑。
+- 验收快照复用未变 Git 对象，只读取变化内容；自动验收共享本次漂移结果，保留全仓变化检测。
+- Canonical 写回复用同次前置检查与写后确认，保留设计新鲜度、CAS 和幂等语义；批量准备、
+  登记检查作为默认调用方式，减少重复状态查询。
+
+## 1.1.0-beta.3
+
+- MEMORY 以可复用开发知识为正文，提炼业务规则、设计原因、修改入口、适用边界与真实踩坑经验；
+  短期记忆写出后即可用于后续开发，没有新增知识时明确记录无新增，不拼凑验收报告。
+- 精简短期记忆模板，移除执行流水、审批、指纹、单次测试统计与无价值内容清单；验收证据保留在
+  原任务日志，通过来源引用追溯，不再要求向记忆全文复制验收字段。
+- 普通与派发协作复用已有方案、实施和 Review 结论完成沉淀，不增加报告、仓库扫描或验证轮次；
+  分析优先读取命中的知识摘要，长期蒸馏过滤历史过程噪声。
+- 升级保留历史记忆与用户模板，新 MEMORY 指令优先于旧模板中的过程栏目；schema 2、归属与
+  完整性校验、滑动窗口及验收流程保持兼容。
+
 ## 1.1.0-beta.2
 
 - 新增 `cooperate_mode: default | dispatch`，支持用户手动派发实现和 QUALITY 内修复，主 Agent

package/README.md

@@ -102,7 +102,9 @@ any stage --[user abort via ec-task-close]--> CLOSED
   `diff_sha256`。用户确认后不重跑 Review Gate：纯非执行差异可沿用
   原验证，可执行差异补定向验证，显式风险豁免单独记录。配置、方案或 Canonical 设计漂移
   不能走这条例外。
-- `MEMORY` 先写入本次任务短期记忆，再执行长期记忆阈值门禁；未超过阈值时长期沉淀为 no-op。
+- `MEMORY` 提炼可直接用于后续开发的知识：业务规则、设计原因、修改入口、适用边界与踩坑经验。
+  复用已有方案、实施和 Review 结论，验收及过程证据留在任务日志，记忆只引用来源；没有新增
+  可复用知识时简短注明，不拼凑报告。短期记忆超过阈值才归并长期知识，否则长期沉淀为 no-op。
 - `ec-lite` 仅由用户显式启停，不是 Fast 的别名。它只保留“紧凑方案 → 用户确认 → 最小实现”，
   不创建任务、Dev-Spec、QUALITY 或 MEMORY；存在活动任务时由用户选择取消启动、关闭任务后
   启动，或只清除当前任务指针后启动。活动任务决策使用 session 级原子锁；每次方案生成一次性
@@ -174,7 +176,7 @@ Dev-Spec 继续走原有整文分析流程。
 | `ec-analysis` | 生成 dev-spec、执行计划和测试策略 |
 | `ec-implementing` | 按确认后的计划执行代码实现；非 TDD 不运行质量命令 |
 | `ec-quality` | 编排 Review/Verification 双门、证据复用和一次性 Repair Bundle |
-| `ec-memory` | 写短期记忆，并在超过阈值时沉淀长期记忆 |
+| `ec-memory` | 提炼可复用开发知识，超过阈值时归并长期记忆 |
 | `ec-task-management` | 任务面板：查看、创建、选择、恢复、交接任务 |
 | `ec-config` | 只读查看或显式修改项目/session 的 Approval、Workflow、单测策略与阈值 |
 | `ec-tdd-init` | 为 UT/TDD 初始化/刷新 Java changed-line coverage 基础设施，不补存量单测 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-coding-harness",
-  "version": "1.1.0-beta.2",
+  "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

@@ -15,9 +15,11 @@ Communicate with the user in the user's language.
 
 1. Read task.json, SOUL, RULES index/headings, ABSTRACT index/headings, and the dev-spec
    skeleton.
-2. Search short-memory frontmatter and summaries first. Open only memories whose domains,
+2. Search short-memory frontmatter and knowledge summaries first. Open only memories whose domains,
    tags, related files, or predecessor links match this task. Do not load the newest five
-   memories unconditionally.
+   memories unconditionally. Skip `memory_value: none` during knowledge retrieval. For legacy
+   reports, read the matching reusable decisions or pitfalls; consult acceptance/process records
+   only when the current task needs that history, not as default development context.
 3. Read full RULES/ABSTRACT sections only for affected modules.
 4. Inspect concrete code paths and tests. Expand context only when evidence reveals another
    dependency or risk.
@@ -206,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-memory/SKILL.md

@@ -1,27 +1,55 @@
 ---
 name: ec-memory
-description: MEMORY-stage skill. Creates a workflow-mode-aware schema-v2 checkpoint from existing task evidence and performs conditional long-memory distillation.
+description: MEMORY-stage skill. Extracts reusable development knowledge from existing task evidence and performs conditional long-memory distillation.
 ---
 
-# ec-memory — evidence-derived checkpoint and knowledge governance
+# ec-memory — reusable knowledge for future development
 
 MEMORY remains mandatory for code tasks. Daily task processing and architecture maintenance are
 separate responsibilities: every completed code task produces one immutable short-memory fact;
 only a long-memory distillation, or the explicit missing-ABSTRACT startup exception, may open an
 architecture assessment. Never update architecture merely because MEMORY was entered.
 
-The short-memory checkpoint must not re-analyze the repository or repeat the entire conversation.
-Generate it only from the verified evidence already stored in `task.json`, `dev-spec.md`, and
-`execution.jsonl`. The bounded repository reads described below belong only to a required
-`backfill` or `update` architecture assessment.
+MEMORY must not re-analyze the repository or repeat the entire conversation. Reuse confirmed
+decisions and verified findings already available in `dev-spec.md`, implementation results and
+Review evidence in `execution.jsonl`; `task.json` supplies identity and frozen mode. The bounded
+repository reads below belong only to a required `backfill` or `update` architecture assessment.
+
+## Knowledge value
+
+A short memory is directly usable knowledge, not an acceptance report. Keep a fact when it helps
+a later task understand behavior, choose the right change, diagnose a failure, or verify correctly.
+
+- Lead with a knowledge topic and a retrieval summary, not a version release or task-completion
+  headline. Prefer business semantics, design reasons, relevant code entrypoints, compatibility
+  boundaries, and observed failure causes with their fixes.
+- State the applicable situation and useful conclusion. Include reasons, limitations and exact
+  symbols or source references where they help the next developer; do not fill a fixed checklist
+  for every fact. Preserve only confirmed conclusions, and keep task-specific scope constraints
+  scoped to that task rather than turning them into permanent project rules.
+- Leave acceptance records in `execution.jsonl`; cite the relevant source instead of copying it.
+  Omit approval JSON, fingerprints, execution timelines, test counts, per-run coverage numbers,
+  temporary log paths, file inventories and handoff history. Do not add a list of excluded noise.
+  A reusable verification command or environment constraint belongs here only when it guides
+  future work; a single run's pass/fail and UT/TDD lifecycle evidence stay in the task record.
+- When no new reusable knowledge exists, set `memory_value: none` and `target_long: NONE`, write
+  a brief reason and retain the source reference. Do not manufacture lessons or duplicate existing
+  knowledge merely to populate sections. This still completes the mandatory short-memory step.
+
+For example, preserve that a cache write may return a failure code without throwing, why proceeding
+with an unpersisted local value breaks shared counting, and where to bypass that behavior. A count
+of passing tests and the user's acceptance timestamp do not teach a future task how to handle it.
+
+Both `default` and `dispatch` use this contract. The coordinator reuses the analysis, implementation
+results and Review findings already available. Reuse any executor-only discovery from its existing
+result; do not require another report, another handoff, or repeated checks for MEMORY.
 
 ## Depth by workflow mode
 
-- `fast`: mechanically produce a compact checkpoint: goal, scope, result, frozen mode,
-  commands/results, and only clearly reusable decisions.
-- `standard`: add reusable contract, compatibility, and troubleshooting facts when present.
-- `strict`: preserve architecture, migration, risk, verification, and cross-module decisions
-  needed for future high-risk work.
+- `fast`: keep the directly reusable conclusions concise.
+- `standard`: include relevant contract, compatibility, and troubleshooting reasons when present.
+- `strict`: retain non-obvious architecture, migration and cross-module boundaries needed by
+  future changes. Greater depth never requires process logs, more checks, or invented knowledge.
 
 Every memory uses schema 2 and includes `workflow_mode` in frontmatter. Generate its UUIDv7 ID
 through:
@@ -33,22 +61,18 @@ through:
 Name it `{memory_id}_{YYYYMMDD}_{smart_name}.md` and set
 `source_task: {current task id, exact}`. Write one immutable short memory under
 `.easy-coding/memory/short/`, then register it with
-`memory-short-complete`. Never invent test results or commit hashes.
+`memory-short-complete`. Task ownership and content integrity remain runtime checks; acceptance
+and Canonical evidence remain in their existing records, not duplicated in the memory body.
 
-Copy the final `acceptance` record from `execution.jsonl` into the checkpoint as a concise
-decision fact: authorization source, decision summary, `diff_sha256`, review policy, verification
-policy, changed files, and any Canonical source tasks that required targeted verification.
-`memory-short-complete` rejects a checkpoint that omits any of those decision fields. This records
-the user's accepted exception without re-reviewing or re-analyzing the code. Canonical writeback
-already carries the same digest and authorization as shared `acceptance` evidence.
-
-For frozen UT/TDD, record the strategy, shared threshold, passed local unit-test result, and
-changed-line coverage result with its frozen baseline. Only TDD includes lifecycle evidence.
-Remote CI is not acceptance evidence. With `none`, omit coverage-specific fields.
+Upgrades preserve existing project templates. These instructions take precedence over legacy
+process sections in `SHORT_MEMORY_TEMPLATE.md`; omit those sections when writing a new memory.
+Do not rewrite old memories or user templates to adopt this contract.
 
 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
-logs, routine command output, or speculation.
+otherwise record `no-op`. Long memory merges reusable facts, deduplicates matching knowledge and
+retires superseded conclusions. Extract useful knowledge from legacy acceptance reports without
+carrying over process noise; `memory_value: none` contributes no long-memory topic. Work only
+within the frozen candidates and matching topics, without a global history cleanup.
 
 ## Architecture assessment
 

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/main-constraint/AGENTS.md.tpl

@@ -125,8 +125,9 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   ANALYSIS reads the selected consumption closure once and treats exact/scope-unchanged as a fast
   projection, while shared execution is the dependency fact source.
 - MEMORY combines short-memory creation and the conditional long-memory gate. Entry follows the
-  effective confirmation mode; its checkpoint records any accepted post-quality diff digest
-  and decision. Once memory processing completes, COMPLETE is automatic.
+  effective confirmation mode. Record reusable development knowledge and source references;
+  acceptance digests and process evidence stay in task records. Do not add reports or repeated
+  checks for memory. Once memory processing completes, COMPLETE is automatic.
 - NO CODE-TASK COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.
 - All cross-platform modules (skills, hooks, references) must use universal agent protocols.
   Do not rely on any specific agent's proprietary conventions unless the module is explicitly

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

@@ -123,8 +123,9 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   ANALYSIS reads the selected consumption closure once and treats exact/scope-unchanged as a fast
   projection, while shared execution is the dependency fact source.
 - MEMORY combines short-memory creation and the conditional long-memory gate. Entry follows the
-  effective confirmation mode; its checkpoint records any accepted post-quality diff digest
-  and decision. Once memory processing completes, COMPLETE is automatic.
+  effective confirmation mode. Record reusable development knowledge and source references;
+  acceptance digests and process evidence stay in task records. Do not add reports or repeated
+  checks for memory. Once memory processing completes, COMPLETE is automatic.
 - NO CODE-TASK COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.
 - All cross-platform modules (skills, hooks, references) must use universal agent protocols.
   Do not rely on any specific agent's proprietary conventions unless the module is explicitly

package/templates/runtime/memory/SHORT_MEMORY_TEMPLATE.md

@@ -11,14 +11,12 @@ domain:
 tags:
   - "{keyword}"
 related_files:
-  - "{key file or module}"
-commit: none
-verification: passed | partial | not_run
+  - "{entrypoint or file useful for applying this knowledge}"
 memory_value: business | technical | both | none
 target_long: BUSINESS | TECHNICAL | BOTH | NONE
 ---
 
-# Short Memory Template
+# {Reusable knowledge topic}
 
 > This template defines the format for files under `.easy-coding/memory/short/`.
 > File naming convention: `{memory_id}_{YYYYMMDD}_{smart_name}.md`
@@ -26,57 +24,32 @@ target_long: BUSINESS | TECHNICAL | BOTH | NONE
 > both the filename prefix and this frontmatter `id`. The UUIDv7 id is safe for concurrent agents.
 > Keep `smart_name` as the readable summary suffix.
 > `source_task` must exactly match the current workflow task id from `task.json`.
-> Short memories are immutable after creation — they serve as a sliding window of recent
-> details and a buffer for long-term distillation candidates.
-> When short memories reach the threshold (default 10), the newest 5 are kept as recent
+> Short memories are immutable and directly useful for later development before distillation.
+> When short memories exceed the threshold (default 10), the newest 5 are kept as recent
 > context; older entries are distillation candidates for long-term memory.
 > Sorting: by frontmatter `date` ascending, then by frontmatter `id`, then by filename. Legacy
 > `SM-YYYYMMDD-NNN` ids sort before UUIDv7 ids on the same date for upgrade compatibility.
 
-## Task Summary
+## Knowledge Summary
 
-- Goal: {the actual problem solved}
-- Scope: {modules, pages, interfaces, or files involved}
-- Result: {completed / partially completed / not completed, with reasons}
-- Key Constraints: {encoding, compatibility, interface, spec, or user-specified constraints; "none" if none}
-- Workflow Mode: {frozen mode and why it was selected or escalated}
+{When this knowledge is useful and the main conclusion a future developer should find.}
 
-## Execution Evidence
+## Reusable Knowledge
 
-| Type | Content |
-|---|---|
-| Key Files | {file or module list; "none" if none} |
-| Verification Commands | {test / build / lint commands and results; explain if not run} |
-| Manual Acceptance | {key behaviors checked; "none" if none} |
-| Commit Info | {commit hash; "none" if not committed} |
+{Write only confirmed facts with future reuse value. Use natural paragraphs or bullets; omit
+inapplicable categories rather than filling a checklist. Useful material includes business rules,
+design reasons, change entrypoints, compatibility boundaries, and failure causes with their fixes.
+Add applicable conditions, necessary reasons and exact symbols where they guide the next change.
+Do not promote a task-specific restriction into a permanent project rule.}
 
-## Business Memory Candidates
+## Sources
 
-> Only record business facts with future reuse value. Write "none" if none.
+- {Relevant dev-spec section, implementation result or Review finding; reference instead of copying.}
+- {Related memory or existing knowledge topic, only when useful.}
 
-- Concepts / Field Semantics: {concepts, fields, enums, state meanings}
-- Workflows / State Transitions: {chain steps, pre/post conditions, exception branches}
-- Business Rules / Compatibility: {admission criteria, decision basis, grayscale or legacy reasons}
-- Upstream/Downstream Contracts: {producers, consumers, interface or message fields}
-- Business Troubleshooting: {common misdiagnosis, priority check paths}
-
-## Technical Memory Candidates
-
-> Only record engineering facts with future reuse value. Write "none" if none.
-
-- Architecture / Interface Decisions: {module boundaries, dependency direction, interface contracts}
-- Engineering Rules / Workflows: {coding, commit, release, installation, directory boundaries}
-- Implementation Patterns / Reusable Approaches: {recommended approaches, fallback strategies, compatibility patterns}
-- Pitfalls / Fix Strategies: {root cause, fix approach, verification method}
-- Verification Experience: {test commands, environment constraints, acceptance paths}
-
-## Non-Distillation Content
-
-> Content that should NOT enter long-term memory, with reasons — prevents accidental absorption of noise.
-
-- {routine file lists / temp logs / one-time data / non-reusable implementation details; "none" if none}
-
-## Related Memories
-
-- Predecessor: {related short memory id, long-term topic, or "none"}
-- Successor: {follow-up task; "none" if none}
+> Authoring guidance, not memory content: remove these instructions and unused placeholders.
+> If nothing new is reusable, set `memory_value: none` and `target_long: NONE`, give a brief reason
+> in Knowledge Summary and retain Sources; omit Reusable Knowledge rather than inventing lessons.
+> Leave task status, approvals, fingerprints, test statistics and temporary logs in task records.
+> Keep a verification command only when it teaches a reusable method or environment requirement.
+> Do not include an acceptance report or a list of excluded noise.

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