deviatdd 2.20.0__tar.gz → 2.20.1__tar.gz

{deviatdd-2.20.0 → deviatdd-2.20.1}/CHANGELOG.md

@@ -36,6 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`/deviate-merge` no longer auto-pushes after the squash-merge commit; the push gate runs inline and the network push is opt-in.** The slash command previously ran `git push` as its final step. As of v2.4.0 the squash-merge commit lands on `main`, then a new `push_gate` step inlines the body of `.githooks/pre-push` (lint + format-check + testmon-driven affected tests with the warm-cache / full-suite fallback — bash 3.2 portable, `GIT_DIR` reset + trap preserved) so the safety net fires even though no `git push` happens yet. After the gate passes the skill asks the operator whether to `git push` (which fires the real `pre-push` hook and re-runs the same gate) or stop and push manually. The squash-merge commit and the ledger transition inside it are durable on `main` regardless of the push outcome — only the network push is deferred. New failure states: `Push_Gate_Failed` (inline gate non-zero), `Push_Failed` (`git push` non-zero, raw stderr surfaced), `Push_Deferred` (user chose "Stop — I'll push manually"). Inline gate body and `.githooks/pre-push` body must stay byte-equivalent; divergence is pinned by `tests/test_meso/test_auto_prompt_templates.py::TestMergePromptPushGate::test_hook_and_prompt_agree_on_gate_body` (which compares non-blank non-comment lines in both bodies and fails on drift in either direction) plus 3 supporting assertions on the upstream-first logic, the testmon fallback, and the prompt structure. Prompt: `src/deviate/prompts/commands/deviate-merge.md` (v2.3.0 → v2.4.0). Spec mirrors updated: `specs/DeviaTDD-architecture.md` (Merge bullet, new `**Push gate + opt-in push (v2.4.0)**` sub-bullet) and `specs/DeviaTDD-api.md` (new `**/deviate-merge push behavior (v2.4.0)**` entry under the `deviate merge` reference).
 
 ### Fixed
+- **Language-agnostic test discovery: the RED gate no longer globs Python-only `tests/**/test_*.py`.** `_find_test_files` returned `[]` for non-Python projects, so `_run_red_phase` rejected a correctly authored Elixir test (`test/integration/tailwind_pipeline_test.exs`) with "RED phase produced no test files" before any command ran — blocking every task on an Elixir/Phoenix repo. The RED gate now trusts the resolved test command (`_test_command_candidates`: task `verification` → constitution `test_command` → `mise run test` → manifest table `mix.exs`→`mix test` / `Cargo.toml`→`cargo test` / `go.mod`→`go test ./...` / `package.json`→`npm test` / `pyproject.toml`→`pytest`), and a project with no resolvable command (returncode 127) routes to the same JUDGE adjudication as pytest's exit-5 no-tests case instead of dying. `deviate red post`, `deviate green post`, and `deviate refactor post` switched their `TEST_NOT_FOUND`/`NO_TESTS_TO_CHECK` gates from the Python glob to the same resolved-command check. `_find_test_files` remains only as the Python fallback signal. Pinned by `tests/test_micro/test_run.py::TestRunCommand::test_run_elixir_repo_red_accepts_exs_test` (fails on the old gate, passes after).
 - **Manifest schema recovery now drops out-of-enum fields instead of aborting the phase (GH-52, GH-55).** `AgentBackend.parse_output` re-constructed a `HandoverManifest` with the offending value intact after a `ValidationError`, so an out-of-enum `failure_kind` (RED) or `next_action` (JUDGE COMPLIANCE_PASS) re-raised the identical error unguarded and the phase died with a misleading `agent returned no manifest`. Recovery now deletes every top-level field that failed validation (the model default `None` applies); the JUDGE runner's existing `_coerce_judge_action` then routes an unknown `next_action` through the legacy pass path. Pinned by `test_recovery_drops_invalid_failure_kind` / `test_recovery_drops_invalid_next_action` in `tests/test_core/test_agent.py`.
 - **`deviate micro run` dedupes latest task records by `(issue_id, task_id)` so a same-numbered task in another issue no longer shadows the active issue's ledger.** `_collect_latest_task_records` previously keyed the latest record by task ID alone. Since every issue reuses the same `TSK-NNN-NN` numbering, a later-sorting ledger (e.g. `specs/adhoc/*` after `specs/005-*`) shadowed the active issue's records — bare `deviate micro run` reported `no ledger entry` against a committed ledger and explicit `<tid>` dispatch hit the wrong issue's task. Latest records are now keyed per issue, and `_find_task_record` prefers the record owned by the current worktree's branch issue. Pinned by `test_find_task_record_prefers_branch_issue` in `tests/test_micro/test_e2e.py`.
 - **`deviate micro run` re-keys a stale worktree session issue to the branch's issue (GH-54).** A freshly claimed worktree could carry the previous issue's id in `.deviate/session.json` while its branch pointed at the new issue; `_resolve_task_context` trusted the stale id, found no tasks board for it in the checkout, and emitted `NO_PENDING_TASKS` exit 0 for a queue that existed. Resolution now prefers the branch-derived issue whenever the session issue differs from it and has no tasks board in the checkout. Pinned by `test_stale_session_issue_rekeys_to_branch_issue` in `tests/test_cli/test_micro.py`.
@@ -56,6 +57,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`deviate shard post` now reliably commits the per-epic `issues/` directory alongside `specs/issues.jsonl`.** When the manifest omits `epic_slug` (or only passes it via `--epic`), the post-script now derives the epic from the first issue's `source_file` and uses a recursive `**/*.md` glob, so the slash command `/deviate-shard` (and its `shard`/`/shard` aliases) commits every shard issue file even if the LLM forgot to write `epic_slug` into the manifest. Missing `issues/` directories and unresolvable epics now emit a visible `SHARD_WARNING` instead of silently producing a ledger-only commit. Implementation lives in `shard_post` (`src/deviate/cli/macro.py`); the pre-script behavior is unchanged. Pinned by `tests/test_integration/test_macro_layer.py::TestShardPost::test_shard_post_commits_issues_directory`.
 - **`mise publish` no longer fails because a stray `.venv-tmp` directory leaks into the source distribution.** Hatchling's hard-coded sdist exclusion list covers `.venv` but not every venv variant, so a `.venv-tmp` left on disk (with its absolute `bin/python` symlink to `/usr/local/bin/python3.13`) was packaged into `dist/deviatdd-*.tar.gz` and `uv build` aborted with `Invalid tar file ... external symlinks are not allowed`. `pyproject.toml` now adds an explicit `[tool.hatch.build.targets.sdist]` exclude of `/.venv-tmp/`, making the build deterministic regardless of hatchling's built-in directory list. The wheel target already scoped packaging to `src/deviate`.
 - **JUDGE feedback commit now passes `--no-verify`.** `_commit_judge_feedback_and_advance` (`src/deviate/cli/micro.py`) issues the docs-only `docs(<tid>): add judge feedback for retry` commit with `--no-verify` so a repository pre-commit hook running the full test suite cannot deadlock the micro loop against a still-broken next-task deliverable. Mirrors the `no_verify=True` pattern already enforced at the RED / GREEN / REFACTOR micro-loop commit sites. Pinned by `tests/test_cli/test_micro.py::TestJudgeTrainRollback::test_commit_judge_feedback_and_advance_uses_no_verify`.
+- **`deviate plan post` / `deviate meso tasks pre` / meso-run resume now auto-fill a missing `**Verification Mode**` line instead of rejecting the plan.** When a plan's acceptance contract fails *only* because scenarios lack the `**Verification Mode**:` line, `_validate_or_repair_plan` (`src/deviate/cli/meso.py`) injects the default `automated` value into each affected scenario body and persists the repaired `plan.md` with a `PLAN_MODE_REPAIR` banner on the console. An existing — even invalid or duplicated — mode literal is never touched, so `invalid Verification Mode` / `duplicate Verification Mode lines` still block with `PLAN_ACCEPTANCE_CONTRACT_INVALID` / `MESO_PLAN_INVALID`. The manual `/deviate-plan` prompt template (`src/deviate/prompts/commands/deviate-plan.md`) now also requires the mode line (per-scenario field 6, canonical example, forbidden patterns, and a pre-write self-check step), matching `src/deviate/prompts/auto/plan.md`. Pinned by `tests/test_core/test_validation.py::TestRepairMissingVerificationMode`, the rewritten `tests/test_meso/test_meso_resume.py::TestMesoIdempotentResume::test_modeless_contract_is_repaired_on_resume`, and `tests/test_cli/test_meso_contracts.py::TestMesoContracts::test_tasks_pre_repairs_missing_verification_mode`.
 ## [2.15.0] - 2026-07-29
 
 ### Added

{deviatdd-2.20.0 → deviatdd-2.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deviatdd
-Version: 2.20.0
+Version: 2.20.1
 Summary: DeviaTDD CLI — agent orchestration framework
 Project-URL: Homepage, https://github.com/wernerbisschoff/deviatdd
 Project-URL: Repository, https://github.com/wernerbisschoff/deviatdd

{deviatdd-2.20.0 → deviatdd-2.20.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deviatdd"
-version = "2.20.0"
+version = "2.20.1"
 description = "DeviaTDD CLI — agent orchestration framework"
 readme = "README.md"
 license = "MIT"

{deviatdd-2.20.0 → deviatdd-2.20.1}/specs/DeviaTDD-api.md

@@ -425,13 +425,13 @@ accepts `--json` (emit JSON contract to stdout) and `--quiet` (suppress output).
     5. **Given / When / Then** — exactly three bold-labelled clauses in this order: `**Given**:`, `**When**:`, `**Then**:`. Each clause is a single imperative sentence and MUST NOT embed additional `**Given**` / `**When**` / `**Then**` markers. The `**Then**` clause MUST state a verifiable observable outcome.
   * **Required sections in canonical order**: `## Plan Summary` → `## Product Layer Anchors` → `## Acceptance Contract` → `## Workstation Mapping` → `## Implementation Strategy` → `## Data Flow Analysis` → `## Risk Assessment` → `## Security Profile` → `## Integration Points` → `## Constitutional Alignment`.
   * **Acceptance Coverage Invariant:** Every AO from the issue's `## Acceptance Outline` MUST appear as the Source Outline of at least one AC-PLAN scenario. Behavioural coverage that does not map cleanly to a single AO (e.g. an HMAC failure, an RLS isolation invariant, a defensive boundary) belongs under an existing AO's Error Category or Boundary Category. If no existing AO fits, the issue's outline is incomplete — halt with `INCOMPLETE_ISSUE_OUTLINE` and request that shard/adhoc regenerate the issue.
-  * **Forbidden patterns** (any one triggers `PLAN_ACCEPTANCE_CONTRACT_INVALID` from `deviate plan post`): Source Outline labelled `Edge Cases`, `Boundary`, `Constitutional §…`, `RLS`, `Tenant Isolation`, `Hardening`, `Security`, or any non-AO string; missing `**Source Outline**` / `**Upstream Traceability**` / `**Current-Code Evidence**` / any of `**Given**` / `**When**` / `**Then**`; missing, repeated, or illegal `**Verification Mode**: <automated|manual|deferred>` (a scenario MUST carry exactly one legal mode line; an empty or non-alphabetic value is treated as missing); an issue AO not used by any AC-PLAN scenario; duplicate or non-sequential `AC-PLAN-NNN` identifiers; wrapping the plan body in any XML tag / code fence / preamble. The validator lives at `src/deviate/core/validation.py::validate_acceptance_contract`.
+  * **Forbidden patterns** (any one triggers `PLAN_ACCEPTANCE_CONTRACT_INVALID` from `deviate plan post`): Source Outline labelled `Edge Cases`, `Boundary`, `Constitutional §…`, `RLS`, `Tenant Isolation`, `Hardening`, `Security`, or any non-AO string; missing `**Source Outline**` / `**Upstream Traceability**` / `**Current-Code Evidence**` / any of `**Given**` / `**When**` / `**Then**`; a repeated or illegal `**Verification Mode**: <automated|manual|deferred>` literal (a scenario MUST carry exactly one legal mode line; an empty or non-alphabetic value is treated as missing); an issue AO not used by any AC-PLAN scenario; duplicate or non-sequential `AC-PLAN-NNN` identifiers; wrapping the plan body in any XML tag / code fence / preamble. A *missing* mode line is not a stopping error: the meso gates auto-fill the default `automated` value into the scenario body (see `deviate plan post`). The validator lives at `src/deviate/core/validation.py::validate_acceptance_contract`; the repair helper is `repair_missing_verification_mode`.
 * **Input Parameters:** `--issue`, `--force`, `--dry-run`; common `--json` / `--quiet` wrappers apply.
 * **Session:** force-transitions to PLAN with `active_issue_id` set.
 
 #### `deviate plan post [--force] [--issue-id]`
 
-Validates plan.md exists, is non-empty, and contains a valid Acceptance Contract; auto-renders HTML when changed, commits with convention-aware messaging, and transitions to TASKS. Missing/malformed contracts fail as `PLAN_ACCEPTANCE_CONTRACT_MISSING` / invalid contract diagnostics.
+Validates plan.md exists, is non-empty, and contains a valid Acceptance Contract; auto-renders HTML when changed, commits with convention-aware messaging, and transitions to TASKS. Missing/malformed contracts fail as `PLAN_ACCEPTANCE_CONTRACT_MISSING` / invalid contract diagnostics. When the contract fails *only* because scenarios lack the `**Verification Mode**:` line, the gate auto-fills `automated` into each affected scenario body, persists the repaired `plan.md` (`PLAN_MODE_REPAIR` banner), and proceeds; an existing invalid or duplicated mode literal still blocks with `PLAN_ACCEPTANCE_CONTRACT_INVALID`.
 
 #### `deviate tasks pre [--force] [--dry-run]`
 
@@ -439,7 +439,7 @@ Validates plan.md exists, is non-empty, and contains a valid Acceptance Contract
 * **Two-source input:** `spec_path` supplies macro intent; `plan_path` supplies strategy and authoritative scenarios. Plan wins over legacy issue/spec Gherkin.
 * **Contract:** detects worktree/branch, resolves constitution commands, and emits `spec_path`, `plan_path`, `tasks_target`, worktree metadata, status, and flags. The issue is resolved from `session.active_issue_id`, falling back to a branch-derived lookup via the `feat/{epic}/{issue}` regex against `specs/issues.jsonl`.
 * **Plan digest:** TASKS receives a bounded 16 KiB UTF-8 `plan_digest` plus `plan_path`; truncation inserts `PLAN_DIGEST_TRUNCATED`, requiring a full read.
-* **Validation:** reports PLAN_NOT_FOUND, PLAN_ACCEPTANCE_CONTRACT_MISSING, or PLAN_ACCEPTANCE_CONTRACT_INVALID; no Gherkin fallback.
+* **Validation:** reports PLAN_NOT_FOUND, PLAN_ACCEPTANCE_CONTRACT_MISSING, or PLAN_ACCEPTANCE_CONTRACT_INVALID; no Gherkin fallback. A contract that fails only for a missing `**Verification Mode**:` line is auto-repaired in place (default `automated`) before the status is computed.
 * **Common Flags:** `--json`, `--quiet`.
 
 #### `deviate tasks post [--force] [--issue-id]`
@@ -538,17 +538,21 @@ accepts `--json` and `--quiet`. `pre` emits a JSON contract describing the envir
 #### `deviate red post`
 
 * **Source:** `src/deviate/cli/micro.py`
-* **Description:** Runs `pytest -v` on all test files. Validates the test fails explicitly
-  (ASSERTION_FAILURE, not PASS or SYNTAX_ERROR), runs the test command, and reports whether the
-  test failed as expected. `deviate micro run`'s internal RED phase (`_run_red_phase`) applies the
-  same contract: when the test command exits 0 (all tests passed) or collects no tests (pytest
-  exit 5), it does NOT die — it routes the decision to JUDGE (``failure_kind: no_failing_test``),
-  which either rules the behavior already exists (task COMPLETED, the uncommitted passing test
-  discarded) or rules the test wrong (``revert_before``, RED re-authors a genuinely failing test).
-  When RED produces no test files at all, `deviate micro run` raises "RED phase produced no test
-  files" naming `/deviate-execute` (DIRECT) or `/deviate-meso` re-sharding. On a genuine failing
-  test it appends the RED status transition to the task ledger, forces session to RED, and commits
-  with `test({scope}): RED phase - failing test`.
+* **Description:** Runs the project's resolved test command (language-agnostic: `mix test`,
+  `cargo test`, `npm test`, `go test ./...`, or `pytest` chosen via the `_test_command_candidates`
+  resolution order — task `verification`, constitution `test_command`, `mise run test`, manifest
+  table, Python fallback). Validates the test fails explicitly (ASSERTION_FAILURE, not PASS or
+  SYNTAX_ERROR), runs the test command, and reports whether the test failed as expected.
+  `deviate micro run`'s internal RED phase (`_run_red_phase`) applies the same contract: when the
+  test command exits 0 (all tests passed), collects no tests (pytest exit 5), or resolves to no
+  command at all (returncode 127), it does NOT die — it routes the decision to JUDGE
+  (``failure_kind: no_failing_test``), which either rules the behavior already exists (task
+  COMPLETED, the uncommitted passing test discarded) or rules the test wrong (``revert_before``,
+  RED re-authors a genuinely failing test). The RED gate does not require a Python
+  ``tests/**/test_*.py`` glob — test discovery follows the project's own convention (e.g.
+  ``test/**/*_test.exs`` for Elixir). On a genuine failing test it appends the RED status
+  transition to the task ledger, forces session to RED, and commits with
+  `test({scope}): RED phase - failing test`.
   Commit messages are convention-aware: when the project declares an emoji convention in
   ``CONTRIBUTING.md`` / ``.commit-convention.md``, the appropriate gitmoji is prepended
   automatically. RED phase `test:` commits are prefixed with 🚨 to flag the failing test (see
@@ -564,8 +568,9 @@ accepts `--json` and `--quiet`. `pre` emits a JSON contract describing the envir
 #### `deviate green post`
 
 * **Source:** `src/deviate/cli/micro.py`
-* **Description:** Verifies a RED transition exists for the active issue. Runs `pytest -v`,
-  requires returncode 0. Appends GREEN transition to ledger, forces session to GREEN,
+* **Description:** Verifies a RED transition exists for the active issue. Runs the project's
+  resolved test command (language-agnostic, e.g. `mix test` / `cargo test` / `pytest`), requires
+  returncode 0. Appends GREEN transition to ledger, forces session to GREEN,
   commits with `feat({scope}): GREEN phase - implementation passes tests`.
 
 #### `deviate judge pre`
@@ -584,9 +589,9 @@ accepts `--json` and `--quiet`. `pre` emits a JSON contract describing the envir
 
 * **Source:** `src/deviate/cli/micro.py`
 * **Description:** Verifies a GREEN transition exists. Appends REFACTOR transition, runs
-  AST-based return type mismatch check, runs pytest before/after to detect regression.
-  On regression, restores via `git restore .` and halts. Commits with
-  `refactor({scope}): REFACTOR phase - code cleanup`.
+  the AST-based return type mismatch check (Python only), runs the resolved test command
+  before/after to detect regression. On regression, restores via `git restore .` and halts.
+  Commits with `refactor({scope}): REFACTOR phase - code cleanup`.
 
 #### `deviate execute pre [--task <id>]`
 
@@ -944,7 +949,7 @@ accepts `--json` and `--quiet`. `pre` emits a JSON contract describing the envir
   * Valid `plan.md` and no `tasks.md`: emit `MESO_RESUME`, skip Plan, and run Tasks.
   * Valid `plan.md` and non-empty `tasks.md`: emit `MESO_ALREADY_COMPLETE`, skip both agents,
     preserve ledger progress, and return the current worktree path.
-  * Existing invalid `plan.md`: emit `MESO_PLAN_INVALID` and stop without overwrite.
+  * Existing `plan.md` valid only after repair: when the contract fails solely for a missing `**Verification Mode**:` line, it is auto-filled (`PLAN_MODE_REPAIR`) and treated as valid; a genuinely invalid `plan.md` (missing clauses, bad AO traceability, illegal/duplicated mode) emits `MESO_PLAN_INVALID` and stops without overwrite.
   * Existing empty `tasks.md`: emit `MESO_TASKS_INVALID` and stop without overwrite.
   A fresh claim does not use inherited main-branch artifacts as resume evidence. It runs Plan
   and Tasks in the new worktree.

{deviatdd-2.20.0 → deviatdd-2.20.1}/specs/DeviaTDD-architecture.md

@@ -274,7 +274,7 @@ to invoke, but model selection is delegated to the calling environment.
     * **Layer discipline:** GREEN's only invariant is "make the RED test pass via the library/API surface declared in scope." It does NOT make scope, spec-drift, or HITL-routing judgments — those belong to JUDGE. When a RED test cannot be satisfied within GREEN's mechanical scope, GREEN emits `status: FAILURE` with a concrete `rationale:` naming the test path and why; `status: "ERROR"` is reserved strictly for tool/orchestration failure. The runner's `_is_hitl_escalation` is a narrow defensive fallback that ONLY promotes structured `contract_drift` / `escalates_to` / `hitl_options` dict keys to `HITL_PENDING` — loose-string `error_kind` discriminators and free-form scope-conflict text do NOT trigger HITL escalation.
     * **Mechanical Failure → JUDGE Routing:** When GREEN emits `status: FAILURE` with a concrete `rationale:` (the mechanical scope-boundary case above), the runner routes control to JUDGE instead of raising `PhaseFailedError`. `_run_green_phase` sets `session.train_feedback = rationale` + `session.failure_kind = "mechanical"` and returns the session; `_run_judge_phase` injects a `<failure_kind>mechanical</failure_kind>` discriminator block into the JUDGE prompt that instructs the agent to emit `verdict: COMPLIANCE_PASS` + `next_action: proceed_to_refactor_no_diff` (when the slice is intrinsically RED-only and REFACTOR's no-op commit + COMPLETED transition is the right termination) OR `verdict: COMPLIANCE_VIOLATION` + one of three `next_action` values (`revert_before` / `revert_to_red` / `skip_refactor`) instead of attempting to satisfy the test itself. This closes the loop where mechanical FAILURE (e.g. slice-scope conflict, CLI-surface-out-of-sco…
     * **Test-Defect Failure → JUDGE Routing:** A second routable failure class, parallel to mechanical but pre-decided. When GREEN observes that the RED test itself is wrong (it asserts behavior the spec does not require, exercises the wrong abstraction, or encodes an assumption that contradicts spec/data-model), GREEN emits `status: FAILURE` with a concrete `rationale:` citing the FR/AC the test contradicts, plus `failure_kind: test_defect` on the manifest (`HandoverManifest.failure_kind: Literal["mechanical", "test_defect", "already_satisfied"] | None` in `src/deviate/core/agent.py` — session mirrors the discriminator as `SessionState.failure_kind: Literal["", "mechanical", "test_defect", "no_failing_test"]` in `src/deviate/state/config.py`). `_run_green_phase` reads the manifest's discriminator, sets `session.failure_kind = "test_defect"`, and routes to JUDGE. `_run_judge_phase` injects a `<failure_kind>test_defect</failure_kind>` discriminator block that pre-decides the routing — `verdict: COMPLIANCE_VIOLATION` + `next_action: revert_before` (re-run RED with the GREEN rationale as feedback) — because test defect has only one sensible outcome: the test itself must be re-authored. The discriminator intentionally narrows the JUDGE routing vocabulary compared to mechanical (`revert_to_red` / `skip_refactor` / `proceed_to_refactor_no_diff` are NOT options in the test_defect block). Default `manifest.failure_kind = None` falls through to `"mechanical"` in the runner to preserve prior behavior.
-    * **RED No-Failing-Test → JUDGE Adjudication (RED → JUDGE direct route):** When RED completes but its test command exits 0 (all tests passed) or collects no tests (pytest exit 5), `_run_red_phase` does NOT raise a raw `PhaseFailedError` and does NOT let GREEN run against a vacuous test. It calls `_adjudicate_red_no_failing_test` (`src/deviate/cli/micro.py`), which sets `session.failure_kind = "no_failing_test"`, injects a `<failure_kind>no_failing_test</failure_kind>` discriminator block into the JUDGE prompt, and dispatches `_run_judge_phase(...)`. The judge diff spans the uncommitted RED test (the `red_baseline` parameter makes `_run_judge_phase` skip the `RED→HEAD` committed diff and surface the agent's uncommitted test through the dirty-parts scan) so JUDGE reviews what the agent actually wrote. JUDGE decides between two outcomes: `verdict: COMPLIANCE_PASS` + `next_action: skip_refactor` (or a bare PASS verdict) when the required behavior already exists — the runner discards the uncommitted passing test via `_restore_worktree_to_baseline` and marks the task COMPLETED without landing it; or `verdict: COMPLIANCE_VIOLATION` + `next_action: revert_before` (forced by the `_coerce_judge_action` runner-level override for `failure_kind` `no_failing_test`/`test_defect`) when the test is wrong — the runner resets to the RED baseline and re-dispatches RED so a fresh genuinely-failing test is authored. `--no-judge` makes the no-failing-test outcome a hard failure (adjudication disabled). When RED produces no test files at all, `_run_red_phase` raises `PhaseFailedError("RED phase produced no test files ...")` naming `/deviate-execute` (DIRECT) or `/deviate-meso` re-sharding — closing the prior stall where an empty `_find_test_files` let RED silently commit a vacuous 'failing test' and GREEN die in `TRAIN_EXHAUSTED`. The RED agent may steer the adjudication by declaring `failure_kind: already_satisfied` (behavior exists) or `failure_kind: test_defect` (test wrong) with a `rationale` on its handover manifest.
+    * **RED No-Failing-Test → JUDGE Adjudication (RED → JUDGE direct route):** When RED completes but its test command exits 0 (all tests passed), collects no tests (pytest exit 5), or resolves to no command at all (returncode 127 from `_run_test_cmd`), `_run_red_phase` does NOT raise a raw `PhaseFailedError` and does NOT let GREEN run against a vacuous test. It calls `_adjudicate_red_no_failing_test` (`src/deviate/cli/micro.py`), which sets `session.failure_kind = "no_failing_test"`, injects a `<failure_kind>no_failing_test</failure_kind>` discriminator block into the JUDGE prompt, and dispatches `_run_judge_phase(...)`. The judge diff spans the uncommitted RED test (the `red_baseline` parameter makes `_run_judge_phase` skip the `RED→HEAD` committed diff and surface the agent's uncommitted test through the dirty-parts scan) so JUDGE reviews what the agent actually wrote. JUDGE decides between two outcomes: `verdict: COMPLIANCE_PASS` + `next_action: skip_refactor` (or a bare PASS verdict) when the required behavior already exists — the runner discards the uncommitted passing test via `_restore_worktree_to_baseline` and marks the task COMPLETED without landing it; or `verdict: COMPLIANCE_VIOLATION` + `next_action: revert_before` (forced by the `_coerce_judge_action` runner-level override for `failure_kind` `no_failing_test`/`test_defect`) when the test is wrong — the runner resets to the RED baseline and re-dispatches RED so a fresh genuinely-failing test is authored. `--no-judge` makes the no-failing-test outcome a hard failure (adjudication disabled). Test discovery is language-agnostic: the RED gate no longer globs Python `tests/**/test_*.py` (`_find_test_files`); the project's own convention is honored through the resolved test command (e.g. `mix test` collecting `test/**/*_test.exs` for Elixir/Phoenix), so a correctly authored non-Python test is neither rejected up front nor silently conflated with "no test framework" — a project with no resolvable test command routes to the same JUDGE adjudication instead of failing. This closes the prior stall where an empty `_find_test_files` let RED silently commit a vacuous 'failing test' and GREEN die in `TRAIN_EXHAUSTED`. The RED agent may steer the adjudication by declaring `failure_kind: already_satisfied` (behavior exists) or `failure_kind: test_defect` (test wrong) with a `rationale` on its handover manifest.
 * **JUDGE / TRAIN (The Compliance Gate) — with Green → Judge → Green loop:**
     * **The Judge:** The CLI evaluates the committed RED-parent-to-HEAD diff against `spec.md` for invariant/security violations. If GREEN tests failed before the implementation commit, `_run_judge_phase` also appends staged/unstaged `git diff HEAD` output and per-file `git diff --no-index /dev/null <path>` output for untracked files, so JUDGE assesses the retained implementation rather than a false RED-only snapshot. This judge operates in a clean, zero-shared-history session to break recursive subjectivity. A `deviate-judge` skill (loaded from `_SKILL_NAMES["JUDGE"]`) guides the agent through supplementary compliance evaluation.
     * **The Train (Green → Judge → Green loop):** On `COMPLIANCE_VIOLATION` or test failure, the CLI safely resets without destroying task progress. The JUDGE phase honors `HandoverManifest.next_action` (see [specs/DeviaTDD-api.md](./DeviaTDD-api.md) for the routing table). The five routes:
@@ -621,17 +621,26 @@ framework's remaining HITL gates are Gate 1 and Gate 3 (Gate 2 was removed).
 
 ## 7. Multi-Framework Testing Abstraction
 
-DeviaTDD's current implementation (`src/deviate/cli/micro.py`) supports **pytest** as its
-test runner via `_run_pytest()`. The abstraction layer is designed to be extensible to other
-frameworks through the `_classify_pytest_outcome()` pattern, which parses stdout/stderr for
-syntax errors, assertion failures, and pass states. Currently, `_run_pytest()` collects all
-`tests/**/test_*.py` files and runs them with `python -m pytest -v`.
+DeviaTDD's current implementation (`src/deviate/cli/micro.py`) runs tests through the
+language-agnostic `_run_test_cmd()` → `_test_command_candidates()` resolution: the task's
+`verification` value, the constitution `test_command`, a `mise run test` task, or the
+`_MANIFEST_TEST_COMMANDS` manifest table (`mix.exs` → `mix test`, `Cargo.toml` → `cargo test`,
+`go.mod` → `go test ./...`, `package.json` → `npm test`, `pyproject.toml` → `pytest`), with a
+Python-only fallback (`_find_test_files` globbing `tests/**/test_*.py` → `pytest`) used only
+when no other framework is detected. Test discovery follows each project's own convention
+(e.g. `test/**/*_test.exs` for Elixir) — the RED gate does not require a Python-style
+`tests/**/test_*.py` file. Outcome classification is shared: a red/green phase is decided by
+the command's exit code plus `_is_no_tests_collected` (pytest exit 5) and `_is_no_test_command`
+(returncode 127) sentinels. `_run_pytest()` remains the Python-specific subprocess runner
+(`tests/**/test_*.py` + `python -m pytest -v`), used where a Python command was resolved.
 
 | Testing Framework | CLI Invocation Strategy | Success Validation | Error Parse Pattern | Scope Protection |
 | :--- | :--- | :--- | :--- | :--- |
-| **Python / pytest** | `python -m pytest tests/ -v` | `returncode == 0` | `_classify_pytest_outcome()`: checks `SYNTAX_ERROR` markers (SyntaxError, IndentationError, etc.), `ASSERTION_FAILURE`, `PASS`, `UNKNOWN_FAILURE`. | Reverts unauthorized test edits before running suite. |
-| **Node.js / Jest** | (Not implemented) | — | — | — |
-| **Go / testing** | (Not implemented) | — | — | — |
+| **Python / pytest** | `python -m pytest tests/ -v` via `_run_pytest()` | `returncode == 0` | `_classify_pytest_outcome()`: checks `SYNTAX_ERROR` markers (SyntaxError, IndentationError, etc.), `ASSERTION_FAILURE`, `PASS`, `UNKNOWN_FAILURE`. | Reverts unauthorized test edits before running suite. |
+| **Elixir / ExUnit** | `mix test` (via `_MANIFEST_TEST_COMMANDS`) | `returncode == 0` | exit code + `_is_no_tests_collected` / `_is_no_test_command` | Same. |
+| **Rust / cargo** | `cargo test` (via `_MANIFEST_TEST_COMMANDS`) | `returncode == 0` | exit code + `_is_no_tests_collected` / `_is_no_test_command` | Same. |
+| **Go / testing** | `go test ./...` (via `_MANIFEST_TEST_COMMANDS`) | `returncode == 0` | exit code + `_is_no_tests_collected` / `_is_no_test_command` | Same. |
+| **Node.js / Jest** | `npm test` (via `_MANIFEST_TEST_COMMANDS`) | `returncode == 0` | exit code + `_is_no_tests_collected` / `_is_no_test_command` | Same. |
 
 ---
 
@@ -903,7 +912,9 @@ there is no `discover_skills()` abstraction.
 **Scope:** Unified Meso and Micro orchestration. The skill first invokes
 `deviate meso run`. In a linked feature worktree, Meso validates existing
 `plan.md` and `tasks.md`, skips completed phases, resumes at Tasks when only
-Plan is ready, and stops on invalid artifacts without overwrite. After Meso
+Plan is ready, auto-repairs a plan whose acceptance scenarios lack the
+`**Verification Mode**:` line (default `automated`, `PLAN_MODE_REPAIR`), and
+stops on genuinely invalid artifacts without overwrite. After Meso
 succeeds, the skill invokes bare `deviate micro run` one task at a time.
 The existing failure triage and clean-slate safety flow remains. **v1.1.0 added a
 `## Troubleshooting failed runs` section** documenting the two

{deviatdd-2.20.0 → deviatdd-2.20.1}/src/deviate/cli/meso.py

@@ -35,7 +35,10 @@ from deviate.core.convention import commit_scope, format_commit_message
 from deviate.core.constitution import extract_commands
 from deviate.core.issues import claim_issue
 from deviate.core.repo import gather_git_state
-from deviate.core.validation import validate_acceptance_contract
+from deviate.core.validation import (
+    repair_missing_verification_mode,
+    validate_acceptance_contract,
+)
 from deviate.core.worktree import (
     branch_exists_on_remote,
     create_worktree,
@@ -815,6 +818,30 @@ def _plan_pre(
     print(json.dumps(contract, indent=2))
 
 
+def _validate_or_repair_plan(content: str) -> tuple[list[str], str]:
+    """Validate a plan contract; auto-fill a missing Verification Mode.
+
+    When the contract fails *only* because scenarios lack a ``**Verification
+    Mode**:`` line, inject the default ``automated`` value and return the
+    repaired body with empty errors. Any other failure (invalid or duplicated
+    mode, missing clauses, bad AO traceability) is returned unchanged so the
+    caller rejects it.
+    """
+    errors = validate_acceptance_contract(content)
+    if not errors:
+        return [], content
+    if not all(e.endswith("missing Verification Mode") for e in errors):
+        return errors, content
+    repaired, count = repair_missing_verification_mode(content)
+    if count == 0:
+        return errors, content
+    console.print(
+        f"[yellow]PLAN_MODE_REPAIR[/] auto-filled {count} missing "
+        "**Verification Mode** line(s) as `automated`"
+    )
+    return validate_acceptance_contract(repaired), repaired
+
+
 def _plan_post(force: bool = False, issue_id: str | None = None) -> None:
     """Validate plan.md, commit it, and advance session to TASKS."""
     session, session_path = _load_session_accept("PLAN", force=force)
@@ -841,7 +868,7 @@ def _plan_post(force: bool = False, issue_id: str | None = None) -> None:
     if not content and not force:
         console.print("[red]PLAN_EMPTY[/] plan.md is empty")
         raise typer.Exit(code=1)
-    acceptance_errors = validate_acceptance_contract(content)
+    acceptance_errors, plan_content = _validate_or_repair_plan(content)
     if acceptance_errors:
         status = (
             "PLAN_ACCEPTANCE_CONTRACT_MISSING"
@@ -850,6 +877,8 @@ def _plan_post(force: bool = False, issue_id: str | None = None) -> None:
         )
         console.print(f"[red]{status}[/] {'; '.join(acceptance_errors)}")
         raise typer.Exit(code=1)
+    if plan_content != content:
+        plan_md.write_text(plan_content, encoding="utf-8")
 
     epic_num = _extract_epic_num(bucket)
     issue_num = _extract_issue_num(resolved_issue_id)
@@ -1001,9 +1030,10 @@ def _tasks_pre(force: bool = False, dry_run: bool = False) -> None:
             "(use --force to bypass)"
         )
     elif plan_path and Path(plan_path).exists():
-        acceptance_errors = validate_acceptance_contract(
-            Path(plan_path).read_text(encoding="utf-8")
-        )
+        plan_text = Path(plan_path).read_text(encoding="utf-8")
+        acceptance_errors, plan_text = _validate_or_repair_plan(plan_text)
+        if plan_text != Path(plan_path).read_text(encoding="utf-8"):
+            Path(plan_path).write_text(plan_text, encoding="utf-8")
         if acceptance_errors:
             missing = acceptance_errors == ["PLAN_ACCEPTANCE_CONTRACT_MISSING"]
             status = (
@@ -1527,10 +1557,12 @@ def _discover_claimable_issue() -> str | None:
 
 
 def _resolve_meso_resume_state(plan_path: Path, tasks_path: Path) -> str:
-    """Return PLAN, TASKS, or COMPLETE without changing existing artifacts."""
+    """Return PLAN, TASKS, or COMPLETE; auto-repair a missing Verification Mode."""
     if plan_path.exists():
         plan_content = plan_path.read_text(encoding="utf-8")
-        plan_errors = validate_acceptance_contract(plan_content)
+        plan_errors, plan_content = _validate_or_repair_plan(plan_content)
+        if plan_content != plan_path.read_text(encoding="utf-8"):
+            plan_path.write_text(plan_content, encoding="utf-8")
         if plan_errors:
             console.print(
                 f"[red]MESO_PLAN_INVALID[/] {plan_path}: {'; '.join(plan_errors)}"

{deviatdd-2.20.0 → deviatdd-2.20.1}/src/deviate/cli/micro.py

@@ -975,6 +975,21 @@ def _resolve_task_context(task_id: str | None, root: Path) -> tuple[dict, Path]
     return pending[0]
 
 
+def _start_phase_from_status(status: str) -> str | None:
+    """Return the phase where a task's run resumes, from its latest JSONL status.
+
+    The tracked ``specs/**/tasks.jsonl`` is authoritative for
+    RED/GREEN/REFACTOR progress; ``session.json`` is an untracked cache that
+    a ``git reset`` does not roll back. ``None`` means start the full RED
+    cycle. Terminal statuses also fall through to ``None`` — their internal
+    ``_phase_already_done`` guards skip re-work."""
+    return {
+        "RED": "GREEN",
+        "GREEN": "JUDGE",
+        "JUDGE": "JUDGE",
+    }.get(status)
+
+
 def _resolve_latest_task(
     root: Path, issue_id: str, status: str
 ) -> tuple[dict, Path] | None:
@@ -1135,6 +1150,18 @@ def _is_no_tests_collected(proc: subprocess.CompletedProcess) -> bool:
     return "no tests" in output
 
 
+def _is_no_test_command(proc: subprocess.CompletedProcess) -> bool:
+    """Return whether the test command could not be resolved.
+
+    ``_run_test_cmd`` returns ``returncode == 127`` with a fixed
+    diagnostic when no command configures and no project is detected,
+    so the RED phase can route that to the same JUDGE adjudication as
+    a pytest ``exit 5`` (``_is_no_tests_collected``)."""
+    if proc.returncode != 127:
+        return False
+    return "no test command" in f"{proc.stderr or ''}".lower()
+
+
 def _run_red_phase(
     task: dict,
     ledger_path: Path,
@@ -1195,17 +1222,12 @@ def _run_red_phase(
     issue_id = task.get("issue_id", "")
     scope = _build_scope(issue_id, tid)
 
-    test_files = _find_test_files(root)
-    if not test_files:
-        raise PhaseFailedError(
-            f"RED phase produced no test files for {tid} — RED must author a "
-            "failing test in a test file the project's test command can "
-            "collect. If the task legitimately needs no code change, take it "
-            "through /deviate-execute (DIRECT) or re-shard via /deviate-meso."
-        )
-
     test_result = _run_test_cmd(root)
-    if test_result.returncode == 0 or _is_no_tests_collected(test_result):
+    if (
+        test_result.returncode == 0
+        or _is_no_tests_collected(test_result)
+        or _is_no_test_command(test_result)
+    ):
         return _adjudicate_red_no_failing_test(
             task,
             ledger_path,
@@ -3529,15 +3551,15 @@ def _run_single(
         c.print(f"[yellow]TASK_ALREADY_DONE[/] {task_id} is already completed")
         raise typer.Exit(code=0)
 
-    if session.pending_judge_feedback:
+    # RED/GREEN/REFACTOR progress is read from the tracked tasks.jsonl, not
+    # from session.json (a git reset reverts the JSONL but not the untracked
+    # session cache). pending_judge_feedback is honored only when the JSONL
+    # still records the implementation the judge rejected.
+    if session.pending_judge_feedback and status in ("RED", "GREEN"):
         session = _resume_pending_judge_feedback(root, task, c, session, session_path)
         start_phase = "GREEN"
     else:
-        start_phase = (
-            session.current_phase
-            if session.current_phase not in ("IDLE", "RED")
-            else None
-        )
+        start_phase = _start_phase_from_status(status)
 
     _dispatch_task(
         task,
@@ -3567,9 +3589,14 @@ def _execute_task_with_retry(
         SessionState.load(session_path) if session_path.exists() else SessionState()
     )
     start_phase: str | None = None
+    # Honor pending_judge_feedback only when the tracked tasks.jsonl still
+    # records the implementation the judge rejected (RED or GREEN). A git
+    # reset that reverts the JSONL to PENDING invalidates stale feedback.
+    status = task.get("status", "PENDING")
     if (
         session.pending_judge_feedback
         and session.pending_judge_feedback.get("task_id") == tid
+        and status in ("RED", "GREEN")
     ):
         session = _resume_pending_judge_feedback(root, task, c, session, session_path)
         start_phase = "GREEN"
@@ -4681,10 +4708,10 @@ def _changed_source_paths(root: Path) -> list[str]:
 @red_app.command(name="post")
 def red_post() -> None:
     root = Path.cwd()
-    test_files = _find_test_files(root)
-
-    if not test_files:
-        console.print("[red]TEST_NOT_FOUND[/]")
+    if not _test_command_candidates(root):
+        console.print(
+            "[red]TEST_NOT_FOUND[/] No test command configured and no test project detected"
+        )
         raise typer.Exit(code=1)
 
     proc = _run_test_cmd(root)
@@ -4792,10 +4819,10 @@ def green_pre(
 @green_app.command(name="post")
 def green_post() -> None:
     root = Path.cwd()
-    test_files = _find_test_files(root)
-
-    if not test_files:
-        console.print("[red]TEST_NOT_FOUND[/]")
+    if not _test_command_candidates(root):
+        console.print(
+            "[red]TEST_NOT_FOUND[/] No test command configured and no test project detected"
+        )
         raise typer.Exit(code=1)
 
     dot_dir = root / ".deviate"
@@ -5066,9 +5093,7 @@ def _check_return_type_mismatch(filepath: str) -> list[str]:
 @refactor_app.command(name="post")
 def refactor_post() -> None:
     root = Path.cwd()
-    test_files = _find_test_files(root)
-
-    if not test_files:
+    if not _test_command_candidates(root):
         console.print("[yellow]NO_TESTS_TO_CHECK[/]")
         raise typer.Exit(code=0)
 

{deviatdd-2.20.0 → deviatdd-2.20.1}/src/deviate/core/validation.py

@@ -177,6 +177,58 @@ def validate_acceptance_contract(content: str) -> list[str]:
     return errors
 
 
+def repair_missing_verification_mode(content: str) -> tuple[str, int]:
+    """Insert a default ``automated`` Verification Mode into every AC-PLAN-NNN
+    scenario absent that line; return the repaired content and repair count.
+
+    Only a genuine absence is filled. An existing mode line — even an
+    invalid or duplicated one — is never touched, so ``validate_acceptance_contract``
+    still rejects those. Callers should gate repair on the contract failing
+    *only* for ``missing Verification Mode`` errors.
+    """
+    lines = content.splitlines()
+    header_idx = next(
+        (i for i, ln in enumerate(lines) if ln.strip() == "## Acceptance Contract"),
+        None,
+    )
+    if header_idx is None:
+        return content, 0
+
+    sec_end = len(lines)
+    for idx in range(header_idx + 1, len(lines)):
+        if lines[idx].lstrip().startswith("## "):
+            sec_end = idx
+            break
+
+    insertions: list[tuple[int, str]] = []
+    i = header_idx + 1
+    while i < sec_end:
+        if lines[i].lstrip().startswith("**Scenario AC-PLAN-"):
+            k = i + 1
+            mode_present = False
+            insert_after: int | None = None
+            while k < sec_end and not lines[k].lstrip().startswith(
+                "**Scenario AC-PLAN-"
+            ):
+                if re.search(r"\*\*Verification Mode\*\*", lines[k], re.IGNORECASE):
+                    mode_present = True
+                if lines[k].strip():
+                    insert_after = k
+                k += 1
+            if not mode_present and insert_after is not None:
+                insertions.append((insert_after, "- **Verification Mode**: automated"))
+            i = k
+        else:
+            i += 1
+
+    if not insertions:
+        return content, 0
+    result = list(lines)
+    for pos, line in sorted(insertions, key=lambda t: t[0], reverse=True):
+        result.insert(pos + 1, line)
+    return "\n".join(result), len(insertions)
+
+
 def validate_sections(content: str | None, required: list[str]) -> list[str]:
     if not content or not content.strip():
         return list(required)

{deviatdd-2.20.0 → deviatdd-2.20.1}/src/deviate/prompts/auto/plan.md

@@ -31,7 +31,8 @@ Identify related issues sharing FR tokens. Check recent git history for commits
 </step>
 
 <step id="acceptance_contract">
-Reconcile every AO-NNN against current code. Emit complete `AC-PLAN-NNN` scenarios under `## Acceptance Contract`, each with Source Outline, Upstream Traceability, Current-Code Evidence, and bold Given/When/Then clauses. This contract is authoritative for Tasks, RED, and JUDGE.
+Reconcile every AO-NNN against current code. Emit complete `AC-PLAN-NNN` scenarios under `## Acceptance Contract`, each with Source Outline, Upstream Traceability, Current-Code Evidence, bold Given/When/Then clauses, and exactly one `**Verification Mode**: <automated|manual|deferred>` line (see required-field 6). This contract is authoritative for Tasks, RED, and JUDGE.
+**Self-check before writing**: enumerate every `AC-PLAN-NNN` you produced and confirm each carries exactly one `**Verification Mode**:` line with a legal literal. A scenario that maps to RED/GREEN tests MUST use `automated`. Do not emit a plan whose scenarios lack this line.
 </step>
 
 <step id="write_plan">
@@ -69,12 +70,13 @@ The CLI orchestrator runs `deviate plan post` after your response to validate pl
 
 ## Acceptance Contract
 
-**Required fields per scenario** — every `AC-PLAN-NNN` MUST contain all five:
+**Required fields per scenario** — every `AC-PLAN-NNN` MUST contain all six:
 1. **Scenario header** — `**Scenario AC-PLAN-NNN: <observable behaviour, imperative present tense>**`. Sequential, zero-padded, unique.
 2. **Source Outline** — `**Source Outline**: \`AO-NNN\`[, \`AO-MMM\`…]`. MUST be a literal AO token from the issue's `## Acceptance Outline`. A comma-separated list is allowed for cross-cutting scenarios. Ad-hoc labels (`Edge Cases`, `Boundary`, `Constitutional §…`, `RLS`, `Tenant Isolation`, `Hardening`, `Security`) are forbidden — `deviate plan post` rejects them with `missing Source Outline AO-NNN traceability`. Every AO from the issue MUST appear as the Source Outline of at least one AC-PLAN scenario.
 3. **Upstream Traceability** — `**Upstream Traceability**: \`US-NNN-NN\`, \`FR-NNN-ID\`, \`AC-NNN-ID-NN\`. At minimum one `US-`, one `FR-`, and one `AC-` token, comma-separated, drawn from the issue's `## Upstream Requirement Tracing` and `## User Stories Ledger`.
 4. **Current-Code Evidence** — `**Current-Code Evidence**: \`<relative path>:<symbol or line>\``. At least one concrete path reference grounded in the codebase scan.
 5. **Given / When / Then** — exactly three bold-labelled clauses in this order: `**Given**:`, `**When**:`, `**Then**:`. Each clause is a single imperative sentence and MUST NOT embed additional `**Given**` / `**When**` / `**Then**` markers. The `**Then**` clause MUST state a verifiable observable outcome.
+6. **Verification Mode** — `**Verification Mode**: <automated|manual|deferred>`. Exactly one per scenario, drawn from the three allowed literals (case-insensitive). `automated` means RED/GREEN executes the scenario as a failing-then-passing test; `manual` means a human verifies it via a documented step; `deferred` means verification is postponed to a later slice. `deviate plan post` rejects a missing, duplicate, or invalid mode literal.
 
 **Canonical example** (the shape to copy):
 **Scenario AC-PLAN-001: <observable behaviour>**
@@ -84,10 +86,11 @@ The CLI orchestrator runs `deviate plan post` after your response to validate pl
 - **Given**: <current, implementation-aware precondition>
 - **When**: <observable trigger>
 - **Then**: <verifiable outcome>
+- **Verification Mode**: automated
 
 **Required sections in canonical order**: `## Plan Summary` → `## Product Layer Anchors` → `## Acceptance Contract` (one or more scenarios; every issue AO covered) → `## Workstation Mapping` → `## Implementation Strategy` → `## Data Flow Analysis` → `## Risk Assessment` → `## Security Profile` → `## Integration Points` → `## Constitutional Alignment`.
 
-**Forbidden patterns** (any one triggers `PLAN_ACCEPTANCE_CONTRACT_INVALID`): non-AO Source Outline labels, missing `Source Outline` / `Upstream Traceability` / `Current-Code Evidence` / any of `Given` / `When` / `Then`, an issue AO not used by any AC-PLAN scenario, duplicate or non-sequential `AC-PLAN-NNN` identifiers, wrapping the plan body in any XML tag / code fence / preamble.
+**Forbidden patterns** (any one triggers `PLAN_ACCEPTANCE_CONTRACT_INVALID`): non-AO Source Outline labels, missing `Source Outline` / `Upstream Traceability` / `Current-Code Evidence` / any of `Given` / `When` / `Then` / `Verification Mode`, missing or duplicate or invalid `**Verification Mode**:` literal, an issue AO not used by any AC-PLAN scenario, duplicate or non-sequential `AC-PLAN-NNN` identifiers, wrapping the plan body in any XML tag / code fence / preamble.
 
 
 ## Workstation Mapping

{deviatdd-2.20.0 → deviatdd-2.20.1}/src/deviate/prompts/commands/deviate-plan.md

@@ -76,12 +76,14 @@ CRITICAL INSTRUCTION INVARIANTS:
    - Every AO from the issue's `## Acceptance Outline` MUST appear as the Source Outline of at least one AC-PLAN-NNN. Unused AOs produce a validation error and the agent must re-emit the contract.
    - Behavioural coverage that does not map cleanly to a single AO (e.g. an HMAC failure, an RLS isolation invariant, a defensive boundary) belongs under an existing AO that already covers the same behaviour, with the AO's Error Category or Boundary Category used to shape the scenario. If no existing AO fits, the issue's `## Acceptance Outline` is incomplete — halt with `INCOMPLETE_ISSUE_OUTLINE` and request that shard/adhoc regenerate the issue rather than inventing a non-AO source.
 8. **Generate `plan.md`**: Write the planning document to the issue workspace using the schema below. `deviate plan post` rejects a missing or malformed Acceptance Contract. The required fields per scenario and per section are non-negotiable — re-read this schema before each emission.
-   **Per-scenario required fields** (every `AC-PLAN-NNN` MUST contain all five):
+   **Per-scenario required fields** (every `AC-PLAN-NNN` MUST contain all six):
    1. **Scenario header** — `**Scenario AC-PLAN-NNN: <observable behaviour, imperative present tense>**`. `AC-PLAN-NNN` is zero-padded three digits, sequential, starting at `AC-PLAN-001`. Identifiers are unique and gap-free.
    2. **Source Outline** — `**Source Outline**: \`AO-NNN\`[, \`AO-MMM\`…]`. The value MUST be an AO token literally present in the issue's `## Acceptance Outline`. A comma-separated list is permitted for cross-cutting scenarios that span multiple AOs. Ad-hoc labels (`Edge Cases`, `Boundary`, `Constitutional §…`, `RLS`, `Tenant Isolation`, `Hardening`, `Security`) are forbidden — see step 7a.
    3. **Upstream Traceability** — `**Upstream Traceability**: \`US-NNN-NN\`, \`FR-NNN-ID\`, \`AC-NNN-ID-NN\`. At minimum one `US-`, one `FR-`, and one `AC-` token, comma-separated, all drawn from the issue's `## Upstream Requirement Tracing` and `## User Stories Ledger` sections.
    4. **Current-Code Evidence** — `**Current-Code Evidence**: \`<relative path>:<symbol or line>\``. At least one concrete path reference grounded in the codebase scan (a module, schema, migration, or test file actually present in the workstation).
    5. **Given / When / Then** — exactly three bold-labelled clauses, in that order: `**Given**:`, `**When**:`, `**Then**:`. Each clause is a single imperative sentence and MUST NOT embed additional `**Given**` / `**When**` / `**Then**` markers. The `**Then**` clause MUST state a verifiable observable outcome.
+   6. **Verification Mode** — `**Verification Mode**: <automated|manual|deferred>`. Exactly one per scenario, drawn from the three allowed literals (case-insensitive). `automated` means RED/GREEN executes the scenario as a failing-then-passing test; `manual` means a human verifies it via a documented step; `deferred` means verification is postponed to a later slice. `deviate plan post` rejects a missing, duplicate, or invalid mode literal.
+   **Pre-write self-check**: Before writing `plan.md`, enumerate every `AC-PLAN-NNN` you produced and confirm each one carries exactly one `**Verification Mode**:` line with a legal literal. A scenario that maps to RED/GREEN tests MUST use `automated`. Do not emit a scenario without this line — the CLI cannot rescue a plan whose scenarios lack a mode.
    **Per-section required structure** (every `plan.md` MUST contain every section below, in this order, with the exact `##` header):
    1. `## Plan Summary` — bullets: Issue, Implementation Strategy, Estimated Complexity, Estimated Effort.
    2. `## Product Layer Anchors` — bullets: Flow References, Source, Release Context, Architecture Components Touched (or `None` when absent).
@@ -95,7 +97,7 @@ CRITICAL INSTRUCTION INVARIANTS:
    10. `## Constitutional Alignment` — Architecture / Testing / Git Isolation / Product Layer bullets.
    **Forbidden patterns** (any one of these causes `PLAN_ACCEPTANCE_CONTRACT_INVALID` from `deviate plan post`):
    - Source Outline labelled `Edge Cases`, `Boundary`, `Constitutional §…`, `RLS`, `Tenant Isolation`, `Hardening`, `Security`, or any non-AO string.
-   - Scenario missing `**Source Outline**`, `**Upstream Traceability**`, `**Current-Code Evidence**`, or any of `**Given**` / `**When**` / `**Then**`.
+   - Scenario missing `**Source Outline**`, `**Upstream Traceability**`, `**Current-Code Evidence**`, any of `**Given**` / `**When**` / `**Then**`, or the `**Verification Mode**:` line.
    - An AO from `## Acceptance Outline` not used by any AC-PLAN-NNN.
    - Two scenarios sharing the same `AC-PLAN-NNN` number, or gaps in the sequence.
    - Wrapping the plan body in any XML tag, code fence, or preamble — write raw Markdown only.
@@ -140,6 +142,7 @@ Write the plan as `plan.md` in the issue workspace directory (adjacent to the is
 - **Given**: <current, implementation-aware precondition>
 - **When**: <observable trigger>
 - **Then**: <verifiable outcome>
+- **Verification Mode**: automated
 
 Each `AO-NNN` MUST map to at least one complete scenario. `AC-PLAN-NNN` identifiers are the authoritative acceptance identities consumed downstream.
 

{deviatdd-2.20.0 → deviatdd-2.20.1}/tests/test_cli/test_meso_contracts.py

@@ -326,16 +326,17 @@ class TestMesoContracts:
 
             return runner.invoke(cli, ["tasks", "pre"])
 
-    def test_tasks_pre_blocks_on_missing_verification_mode(
-        self, tmp_path: Path
-    ) -> None:
+    def test_tasks_pre_repairs_missing_verification_mode(self, tmp_path: Path) -> None:
         plan_text = self._contract_plan(mode_line=None)
         result = self._invoke_tasks_pre_with_plan(tmp_path, plan_text)
 
         assert result.exit_code == 0, result.output
         contract = self._extract_contract(result.output)
-        assert contract["status"] == "PLAN_ACCEPTANCE_CONTRACT_INVALID", result.output
-        assert "AC-PLAN-001: missing Verification Mode" in result.output
+        assert contract["status"] == "READY", result.output
+        assert "PLAN_MODE_REPAIR" in result.output
+        plan_path = tmp_path / "specs" / "test-epic" / "ISS-TEST-001" / "plan.md"
+        repaired = plan_path.read_text(encoding="utf-8")
+        assert "**Verification Mode**: automated" in repaired
 
     def test_tasks_pre_blocks_on_illegal_verification_mode(
         self, tmp_path: Path