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

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

@@ -12,8 +12,9 @@ user's language.
 
 ```text
 INIT --auto--> ANALYSIS -> IMPLEMENT -> QUALITY -> MEMORY --auto--> COMPLETE
-                    ^           ^          |
-                    +--replan---+          +---repair-----+
+                    ^                      |
+                    +---- scope/contract replan -----+
+                                  QUALITY -- bounded repair --> QUALITY
 
 any active stage --explicit user abort--> CLOSED
 ```
@@ -27,23 +28,24 @@ Pure conversation, explanation, analysis, and read-only review stay Ready and cr
 - `approval_mode = approve|guard|confirm|auto` controls whether a legal transition waits for a
   user. `confirm` waits only at ANALYSIS -> IMPLEMENT; after that, green QUALITY, MEMORY, and
   COMPLETE transitions advance automatically. `auto` advances every legal green
-  edge. The only additional pause is an exceptional code diff detected after the frozen
+  edge. Dispatch keeps its explicit scope/executor decision; another pause is an exceptional code diff detected after the frozen
   QUALITY acceptance checkpoint; accepting that exact diff does not change the mode.
 - `workflow_mode = adaptive|fast|standard|strict` controls execution cost and assurance depth.
-- `tdd_enabled` independently activates Java TDD and changed-line coverage. It defaults off;
-  `tdd_coverage_threshold` defaults to 90 and accepts integers from 1 to 100.
+- `unit_test_mode` independently selects `none`, `ut`, or `tdd`. It defaults to `none`;
+  `ut_coverage_threshold` defaults to 90 and accepts integers from 1 to 100.
 
-Approval and TDD retain session-over-project precedence. Execution depth is always the
+Approval, cooperation and unit test settings use session > local > project > defaults, per field.
+Local preferences live in optional `~/.easy-coding/config.yaml`; reads never create it. Execution depth is always the
 mechanically calculated minimum for the current change. Do not recommend, select a higher mode,
 or inherit an old task mode. Persist it once with `propose-workflow-mode --agent <agent-id>
 --session-file <P>`; the runtime calculates and freezes the value.
 
-TDD resolves with the same session-over-project precedence and freezes its enabled flag and
-threshold on ANALYSIS -> IMPLEMENT. It may be enabled only after `ec-tdd-init` readiness passes;
-there is no enabled-but-pending-initialization state. A dedicated `tdd-init` task always freezes
-TDD off so it can create or repair the required infrastructure without circular gating. When off,
-ordinary tasks add no CI scan, artifacts, commands, coverage work, or stronger acceptance. Use
-`ec-config` for all mode configuration.
+Unit test strategy uses the same three-scope precedence and freezes its mode and
+`ut_coverage_threshold` on ANALYSIS -> IMPLEMENT. UT and TDD share passed local unit tests and
+changed-line coverage, and reuse `ec-tdd-init` readiness. Only TDD requires test-first lifecycle
+and its review dimension. UT keeps ordinary review and compact Fast planning. The `tdd-init`
+task itself freezes strategy `none`; `none` adds no infrastructure scan or coverage gate.
+Both strategies reuse input-bound results and do not raise workflow depth.
 
 `confirm` and `auto` do not hide the proposal: show it in the plan. Confirm waits for that one
 plan decision; Auto continues immediately. Both remove later waiting, not quality gates.
@@ -126,7 +128,7 @@ or `qoder`. Never use a display or source-author attribution such as `Codex with
    `type=tdd-init` code task only after scope confirmation. Do not reinterpret it as an ordinary
    TDD-enabled feature task and do not require readiness before creating it.
 5. Match the user's intent against `current_task` and the active task list before resuming.
-   If the user names or clearly matches another task, confirm the switch and call
+   If the user explicitly selects another task, that selection authorizes the switch; call
    `claim-task --task-id <id> --agent <agent-id> --session-file <P>`. Do not execute task A
    under task B's request.
    - With no explicit repository-mutation request, stay Ready and answer normally. Ambiguous
@@ -139,7 +141,23 @@ or `qoder`. Never use a display or source-author attribution such as `Codex with
 6. Resume the matched/current task, then load only state-relevant assets. Do not read five full
    memories at every startup; ANALYSIS searches memory metadata and opens relevant entries on
    demand.
-7. If another Agent last owned the task, summarize the stored handoff before continuing.
+7. Honor the returned `continuation` before generic stage dispatch. Summarize the existing handoff,
+   consume its approved scope and references, and stop at `stop_after`. Never create a new task,
+   replan, or ask again to approve already accepted work merely because the Agent changed.
+   `cooperation.coordinator` stays the main Agent/session while `last_agent` tracks the executor.
+   A repeated claim of the same active task does not require another claim record.
+
+## Manual dispatch
+
+`cooperate_mode=default` preserves handoff at stage boundaries. `dispatch` also supports handing
+a QUALITY repair to another Agent without changing stage. The user manually switches Agents.
+At an implementation decision, offer current-Agent execution, handoff, or defer/change once.
+"Confirm and hand off" consumes the existing pending stage approval before writing a handoff;
+"handoff for analysis" alone does not approve implementation. Do not ask again on claim.
+Use `handoff-task --continuation` with `next_action`, existing `unit_ids`, optional `evidence_refs`,
+and `stop_after`. Implement-only handoff uses `next_action:implement, stop_after:IMPLEMENT`;
+on completion return `next_action:quality` to the coordinator. QUALITY repairs follow ec-quality.
+The user can authorize the coordinator to fix a small change directly in either mode.
 
 ## Stage dispatch
 
@@ -158,7 +176,8 @@ clears the pending action so the corrected action can proceed; never overwrite a
 pending action.
 
 Creation and claim return `spec_context.consumption` for the stored selection. Consume it before
-dispatching a stage. After session resume or design sync, call `resume-spec-context --agent
+dispatching a stage. Reuse a matching current-session receipt (`spec_context.reused:true`) and context already loaded.
+If context was lost, the session is new, or design changed, call `resume-spec-context --agent
 <agent-id> --session-file <P>` and consume its returned closure. A blocked context requires
 source repair or design sync; never continue from a handoff summary alone. If `spec_change` is
 pending, resume that confirmed change on the bound original file before implementation/QUALITY.
@@ -211,8 +230,9 @@ acceptance-diff choice and returns to the stage required by the state API.
 For an explicitly confirmed rollback, scope reduction, or bounded correction of an active task,
 call `begin-correction --file <existing-task-file> ... --summary <confirmed-change>
 [--risk <actual-new-risk>] --agent <agent-id> --session-file <P>`. The runtime preserves the plan,
-unaffected Units and evidence, consumes old QUALITY state, and enters IMPLEMENT at the mechanical
-minimum for these files. Do not reconstruct the original task or its documents. Synchronize only
+unaffected Units and evidence. In QUALITY it prepares an in-stage repair bundle; use
+`start-quality-repair` and `complete-quality-repair` without a stage transition. Other active stages
+use IMPLEMENT at the mechanical minimum for these files. Do not reconstruct the original task or its documents. Synchronize only
 conflicting source Spec clauses once when needed; then continue the correction. Never restore an
 entire file over unrelated user edits. A new feature or expanded contract still needs ANALYSIS.
 

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

@@ -12,9 +12,9 @@ Start every work reply with the single Markdown blockquote status line injected
 then a blank line. Do not render the machine breadcrumbs to the user.
 
 `{approval-mode}` is the effective approval mode and `{workflow-mode}` is the configured or
-task-frozen execution mode; session overrides take precedence over project settings.
-When effective/frozen TDD is enabled, insert `· **TDD**` immediately after Workflow. When it is
-disabled, omit the TDD segment entirely and preserve the existing status-line format.
+task-frozen execution mode; behavior settings resolve per field: session > optional local ~/.easy-coding/config.yaml > project > defaults.
+When effective/frozen unit_test_mode is `ut` or `tdd`, insert `· **UT**` or `· **TDD**`
+immediately after Workflow. For `none`, omit this segment and preserve the status-line format.
 
 - Ready: > **Easy Coding** · **Approval: {approval-mode}** · **Workflow: {workflow-mode}** · Ready · Use `ec-workflow` to start or resume a task, `ec-brainstorming` to brainstorm, `ec-task-management` to manage tasks, or `ec-config` to inspect or change modes
 - Waiting init: > **Easy Coding** · **Approval: {approval-mode}** · **Workflow: {workflow-mode}** · Waiting init · Use `ec-init` to initialize
@@ -34,7 +34,7 @@ Trigger Easy Coding skills with your platform prefix — Codex: `$ec-*`, Qoder:
 - `ec-brainstorming` — design exploration before building (hard design gate)
 - `ec-analysis` `ec-implementing` `ec-quality` — workflow stages
 - `ec-memory` — short/long memory archive
-- `ec-task-management` — task lifecycle panel · `ec-config` — Approval/Workflow/TDD settings · `ec-tdd-init` — Java changed-line gate initialization · `ec-task-close` — interrupt a task
+- `ec-task-management` — task lifecycle panel · `ec-config` — Approval/Workflow/unit-test settings · `ec-tdd-init` — Java changed-line gate initialization · `ec-task-close` — interrupt a task
 - `ec-no-harness` — bypass only Easy Coding for the current session
 - `ec-lite` — user-controlled direct mode with one proposal confirmation and no task/QUALITY/MEMORY
 - `ec-git` — git discipline · `ec-meta` — understand/customize the harness
@@ -43,25 +43,27 @@ First run `ec-init`; daily work goes through `ec-workflow`.
 
 ## Workflow discipline
 
-- Approval mode is session override > project `behavior.approval_mode` > `guard`; workflow mode
+- Approval mode is session override > local ~/.easy-coding/config.yaml > project `behavior.approval_mode` > `guard`; workflow mode
   is the mechanical minimum for the current actual change. Approval controls waiting;
   workflow controls execution depth. Do not recommend or inflate the calculated mode.
   Confirm approval waits only at ANALYSIS -> IMPLEMENT, then advances green later stages
-  automatically; Auto advances all legal green edges. A new code diff after the QUALITY
-  checkpoint is the only exceptional pause across all modes: show the exact diff, bind acceptance
+  automatically; Auto advances all legal green edges. Dispatch retains the explicit scope/executor
+  decision, merged with any required approval. A new code diff after the QUALITY
+  checkpoint also pauses across all modes: show the exact diff, bind acceptance
   to its digest, and continue without rereview when the user accepts.
   Every mutation task runs QUALITY; no mode changes scope, delivery form, or evidence gates.
-- TDD is session override > project `behavior.tdd_enabled` > `false`; its changed-line threshold
-  is session override > project `behavior.tdd_coverage_threshold` > `90`. ANALYSIS -> IMPLEMENT
-  freezes both. TDD may be enabled only after `ec-tdd-init` records valid infrastructure readiness;
-  build version/content changes require fresh task evidence, not reinitialization. Repair missing
-  local entries without resetting TDD; CLI upgrades preserve project/session/frozen task settings;
-  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, 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.
+- Unit test strategy is session override > local ~/.easy-coding/config.yaml > project `behavior.unit_test_mode` > `none`.
+  Values are `none`, `ut`, and `tdd`; both enabled strategies share `ut_coverage_threshold`
+  (session > local > project > 90, integer 1..100). ANALYSIS -> IMPLEMENT freezes strategy, threshold,
+  and repository baselines. `none` adds no coverage work and retains ordinary task verification.
+  UT requires passed local unit tests and changed-production-line coverage, without test-first
+  ordering, RED/GREEN artifacts, or a separate TDD review. TDD additionally requires its lifecycle
+  and review dimension. Assertions remain part of ordinary review in UT.
+  Both currently support Java and reuse `ec-tdd-init` readiness, JaCoCo, and existing evidence
+  reuse. One test execution supplies tests plus coverage. No new stages or workflow escalation.
+  The dedicated `tdd-init` task freezes strategy `none`; readiness failure reports repair rather
+  than resetting configuration. CLI upgrades migrate old fields and preserve frozen task progress.
+  GitLab automation is infrastructure, not remote acceptance evidence.
 - Confirmation-required edges use `pending_transition`; automatic edges use the restricted
   `auto-transition` API. Pure read-only conversation stays Ready and creates no task. Any
   repository write, including documentation or configuration, uses the full state machine.
@@ -112,7 +114,7 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   Runtime progress must use the shared writer with CAS/idempotency and reconciliation; static
   confirmed design changes first use `begin-spec-change`, then revision + READY + `sync-spec-design`.
   Creation/claim returns selected source context; session resume and design sync require
-  `resume-spec-context` before work. Pending changes block implementation/acceptance across agents.
+  `resume-spec-context` only when current-session context is missing or design changed; otherwise reuse it. Pending changes block implementation/acceptance across agents.
   Preserve the original writer actor while retaining the current owner during reconciliation.
   Never hand-edit `EDS:EXECUTION`.
   Selected source tasks remain `implemented` through local QUALITY and become `verified`
@@ -165,3 +167,19 @@ speculative fallback/retry/compatibility logic, or defensive copying.
 
 Add project-specific instructions below this line. The generated region above is managed by
 easy-coding-harness and is replaced on `easy-coding upgrade`.
+
+## Cooperation and bounded QUALITY repair
+
+`cooperate_mode: default | dispatch` is independent of approval and unit-test strategy, with
+session > optional local `~/.easy-coding/config.yaml` > project > default precedence. Reads never
+create local config; ec-config changes only explicitly selected fields and can restore inheritance.
+Default preserves stage-boundary handoff. Dispatch supports manual implementation and QUALITY
+repair handoff; the user can always select current-Agent execution. Preserve the task coordinator,
+use existing plan/evidence references and stop at the handoff's `stop_after`. Never launch another Agent.
+Dispatch requires one user decision on scope and executor, even under Auto; combine any approval
+with that same decision and never ask again on claim. Ordinary repairs stay in QUALITY using
+begin-correction, start-quality-repair and complete-quality-repair. Only changed requirements,
+contracts or a replaced main implementation plan justify returning to ANALYSIS/IMPLEMENT.
+Review and verification remain read-only checks; approved repairs happen between them. Reuse
+unaffected evidence, review the repair delta and run affected checks only. Do not rebuild the plan
+or repeat completed checks because of handoff, stage labels or descriptive check-name changes.

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

@@ -12,9 +12,9 @@ Start every work reply with the single Markdown blockquote status line injected
 then a blank line. Do not render the machine breadcrumbs to the user.
 
 `{approval-mode}` is the effective approval mode and `{workflow-mode}` is the configured or
-task-frozen execution mode; session overrides take precedence over project settings.
-When effective/frozen TDD is enabled, insert `· **TDD**` immediately after Workflow. When it is
-disabled, omit the TDD segment entirely and preserve the existing status-line format.
+task-frozen execution mode; behavior settings resolve per field: session > optional local ~/.easy-coding/config.yaml > project > defaults.
+When effective/frozen unit_test_mode is `ut` or `tdd`, insert `· **UT**` or `· **TDD**`
+immediately after Workflow. For `none`, omit this segment and preserve the status-line format.
 
 - Ready: > **Easy Coding** · **Approval: {approval-mode}** · **Workflow: {workflow-mode}** · Ready · Use `ec-workflow` to start or resume a task, `ec-brainstorming` to brainstorm, `ec-task-management` to manage tasks, or `ec-config` to inspect or change modes
 - Waiting init: > **Easy Coding** · **Approval: {approval-mode}** · **Workflow: {workflow-mode}** · Waiting init · Use `ec-init` to initialize
@@ -32,7 +32,7 @@ platform prefixes such as `/` or `$`. If no status line is injected, do not inve
 - `/ec-brainstorming` — design exploration before building (hard design gate)
 - `/ec-analysis` `/ec-implementing` `/ec-quality` — workflow stages
 - `/ec-memory` — short/long memory archive
-- `/ec-task-management` — task lifecycle panel · `/ec-config` — Approval/Workflow/TDD settings · `/ec-tdd-init` — Java changed-line gate initialization · `/ec-task-close` — interrupt a task
+- `/ec-task-management` — task lifecycle panel · `/ec-config` — Approval/Workflow/unit-test settings · `/ec-tdd-init` — Java changed-line gate initialization · `/ec-task-close` — interrupt a task
 - `/ec-no-harness` — bypass only Easy Coding for the current session
 - `/ec-lite` — user-controlled direct mode with one proposal confirmation and no task/QUALITY/MEMORY
 - `/ec-git` — git discipline · `/ec-meta` — understand/customize the harness
@@ -41,25 +41,27 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
 
 ## Workflow discipline
 
-- Approval mode is session override > project `behavior.approval_mode` > `guard`; workflow mode
+- Approval mode is session override > local ~/.easy-coding/config.yaml > project `behavior.approval_mode` > `guard`; workflow mode
   is the mechanical minimum for the current actual change. Approval controls waiting;
   workflow controls execution depth. Do not recommend or inflate the calculated mode.
   Confirm approval waits only at ANALYSIS -> IMPLEMENT, then advances green later stages
-  automatically; Auto advances all legal green edges. A new code diff after the QUALITY
-  checkpoint is the only exceptional pause across all modes: show the exact diff, bind acceptance
+  automatically; Auto advances all legal green edges. Dispatch retains the explicit scope/executor
+  decision, merged with any required approval. A new code diff after the QUALITY
+  checkpoint also pauses across all modes: show the exact diff, bind acceptance
   to its digest, and continue without rereview when the user accepts.
   Every mutation task runs QUALITY; no mode changes scope, delivery form, or evidence gates.
-- TDD is session override > project `behavior.tdd_enabled` > `false`; its changed-line threshold
-  is session override > project `behavior.tdd_coverage_threshold` > `90`. ANALYSIS -> IMPLEMENT
-  freezes both. TDD may be enabled only after `ec-tdd-init` records valid infrastructure readiness;
-  build version/content changes require fresh task evidence, not reinitialization. Repair missing
-  local entries without resetting TDD; CLI upgrades preserve project/session/frozen task settings;
-  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, 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.
+- Unit test strategy is session override > local ~/.easy-coding/config.yaml > project `behavior.unit_test_mode` > `none`.
+  Values are `none`, `ut`, and `tdd`; both enabled strategies share `ut_coverage_threshold`
+  (session > local > project > 90, integer 1..100). ANALYSIS -> IMPLEMENT freezes strategy, threshold,
+  and repository baselines. `none` adds no coverage work and retains ordinary task verification.
+  UT requires passed local unit tests and changed-production-line coverage, without test-first
+  ordering, RED/GREEN artifacts, or a separate TDD review. TDD additionally requires its lifecycle
+  and review dimension. Assertions remain part of ordinary review in UT.
+  Both currently support Java and reuse `ec-tdd-init` readiness, JaCoCo, and existing evidence
+  reuse. One test execution supplies tests plus coverage. No new stages or workflow escalation.
+  The dedicated `tdd-init` task freezes strategy `none`; readiness failure reports repair rather
+  than resetting configuration. CLI upgrades migrate old fields and preserve frozen task progress.
+  GitLab automation is infrastructure, not remote acceptance evidence.
 - Confirmation-required edges use `pending_transition`; automatic edges use the restricted
   `auto-transition` API. Pure read-only conversation stays Ready and creates no task. Any
   repository write, including documentation or configuration, uses the full state machine.
@@ -110,7 +112,7 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   Runtime progress must use the shared writer with CAS/idempotency and reconciliation; static
   confirmed design changes first use `begin-spec-change`, then revision + READY + `sync-spec-design`.
   Creation/claim returns selected source context; session resume and design sync require
-  `resume-spec-context` before work. Pending changes block implementation/acceptance across agents.
+  `resume-spec-context` only when current-session context is missing or design changed; otherwise reuse it. Pending changes block implementation/acceptance across agents.
   Preserve the original writer actor while retaining the current owner during reconciliation.
   Never hand-edit `EDS:EXECUTION`.
   Selected source tasks remain `implemented` through local QUALITY and become `verified`
@@ -160,3 +162,19 @@ speculative fallback/retry/compatibility logic, or defensive copying.
 
 Add project-specific instructions below this line. The generated region above is managed by
 easy-coding-harness and is replaced on `easy-coding upgrade`.
+
+## Cooperation and bounded QUALITY repair
+
+`cooperate_mode: default | dispatch` is independent of approval and unit-test strategy, with
+session > optional local `~/.easy-coding/config.yaml` > project > default precedence. Reads never
+create local config; ec-config changes only explicitly selected fields and can restore inheritance.
+Default preserves stage-boundary handoff. Dispatch supports manual implementation and QUALITY
+repair handoff; the user can always select current-Agent execution. Preserve the task coordinator,
+use existing plan/evidence references and stop at the handoff's `stop_after`. Never launch another Agent.
+Dispatch requires one user decision on scope and executor, even under Auto; combine any approval
+with that same decision and never ask again on claim. Ordinary repairs stay in QUALITY using
+begin-correction, start-quality-repair and complete-quality-repair. Only changed requirements,
+contracts or a replaced main implementation plan justify returning to ANALYSIS/IMPLEMENT.
+Review and verification remain read-only checks; approved repairs happen between them. Reuse
+unaffected evidence, review the repair delta and run affected checks only. Do not rebuild the plan
+or repeat completed checks because of handoff, stage labels or descriptive check-name changes.

package/templates/runtime/tools/easy_coding_java_coverage.py

@@ -191,16 +191,16 @@ def read_project_threshold(repo: Path) -> int:
                 schema_version = 0
             continue
         if (
-            schema_version >= 4
+            schema_version >= 6
             and in_behavior
-            and stripped.startswith("tdd_coverage_threshold:")
+            and stripped.startswith("ut_coverage_threshold:")
         ):
             try:
                 value = int(stripped.split(":", 1)[1].strip().strip("'\""))
             except ValueError as error:
-                raise CoverageError("Invalid behavior.tdd_coverage_threshold") from error
+                raise CoverageError("Invalid behavior.ut_coverage_threshold") from error
             if not 1 <= value <= 100:
-                raise CoverageError("TDD coverage threshold must be from 1 to 100")
+                raise CoverageError("Unit test coverage threshold must be from 1 to 100")
             return value
     return DEFAULT_THRESHOLD
 
@@ -294,7 +294,7 @@ def main() -> int:
             else read_project_threshold(repo)
         )
         if not 1 <= threshold <= 100:
-            raise CoverageError("TDD coverage threshold must be from 1 to 100")
+            raise CoverageError("Unit test coverage threshold must be from 1 to 100")
         reports = (
             sorted({Path(item).resolve() for item in args.report})
             if args.report

package/templates/shared-hooks/easy_coding_inputs.py

@@ -40,6 +40,24 @@ def memo(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):
+        return command
+    return tuple(shlex.split(command))
+
+
 def digest(value):
     return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False,
                                      separators=(",", ":")).encode()).hexdigest()
@@ -255,7 +273,7 @@ def input_spec(root, task, plan, check):
                            "tests" if builds_module else "tests/fixtures"):
                 if (base / config).is_dir():
                     paths.add(config)
-    if task.get("tdd_enabled") is True:
+    if task.get("unit_test_mode") in {"ut", "tdd"}:
         for directory in {str(root.resolve()), *repositories}:
             manifest = Path(directory) / ".easy-coding/tdd/readiness.json"
             if manifest.is_file():