aw-spec-cli 0.1.32 → 0.1.34

package/assets/.appweaver/orchestrator/workflows/aw-spec-fix-test-coverage.orch.yaml

@@ -0,0 +1,965 @@
+# =============================================================================
+# aw-spec-fix-test-coverage (orchestrator) — write the tests no requirement has
+#
+# The repair step for the gap the two slice gates report. analyze-slice reads each worked
+# lane's master plan for the FR- and BR- ids its Traceability section traces, and
+# analyze-slice-delta reads the ids a change's delta plan rows serve; both look for each id
+# in the feature's test files (`test-citations`) and fail when a test names none. Green
+# tests cannot show a requirement whose test was never written, which is why those gates
+# exist — and this is what closes what they find.
+#
+#   /appweaver fix-test-coverage            the master plans' ids        → then analyze-slice
+#   /appweaver fix-test-coverage <CR-id>    that change's delta-plan ids → then build →
+#                                                                          analyze-slice-delta
+# With no id it works from the master plans even when changes are open; an id that names
+# no open change stops and lists the open ones.
+#
+# TESTS ONLY. For each id no test names, the model reads what the requirement or invariant
+# states, finds the code that realises it, and writes a test of that behaviour naming the
+# id — or, where a test of the feature already exercises it, adds the id to that test.
+# Production code is never written here: an id whose behaviour the code does not realise is
+# reported `not-implemented` and left for /appweaver implement, because a test written
+# against missing behaviour either passes without checking anything or fails for a reason
+# no test edit can fix.
+#
+# THE REQUIREMENT TEXT IS IN CONTEXT, unlike implement. implement realises the PLAN and is
+# deliberately kept from the spec so a gap in the plan is found rather than compensated for.
+# A test checks the REQUIREMENT, so the spec (or the change's delta spec) and the domain
+# model are what it is written from; the plan is the map from an id to the element that
+# realises it.
+#
+# THE SCRIPT DECIDES, NOT THE MODEL. After the tests are written the lane's tests run, and
+# `test-citations` runs again: an id is closed when a test names it and the suite is green,
+# whatever the model reported.
+#
+# A NEW TEST THAT FAILS gets at most two repair passes, and those may change only the files
+# this run wrote, only for what is mechanical — a test that does not compile, a missing
+# import, the wrong fixture or setup. Never production code, never another test, never
+# what an assertion expects. A test that runs and fails its assertion has found a place
+# where the code does not do what the requirement says: it is reported as a suspected
+# defect and the run stops, with the test kept as the evidence.
+#
+# AN ADOPTED FEATURE IS NOT EXEMPT. Its plans carry `origin: reverse-engineered`, and the
+# gates only report its gaps. Its spec was reversed from the code, so a test of what the spec
+# states should pass against it; one that fails is a mismatch between the adopted spec and
+# the code — reported, never fixed in the code.
+#
+# ONLY THE LANES YOU WORK ON (.appweaver/lane.json), and on a change only those it names
+# that have its delta plan. Each lane is confirmed before anything is written, and loads the
+# rule set its tests were first generated under (`## /aw-spec-implement-<lane>`), so no
+# project needs new configuration for this command.
+#
+# Launch:  /appweaver fix-test-coverage [CR-id]
+# Prereq:  analyze-slice (or analyze-slice-delta <CR-id>) reported requirements no test names.
+# =============================================================================
+
+name: aw-spec-fix-test-coverage
+version: 1.0.0
+description: "Write the tests the slice gates found missing — for every FR- and BR- id a lane's plan traces (no argument: the master plans' Traceability, the ids analyze-slice checks) or a change's delta plan rows serve (a CR id: the ids analyze-slice-delta checks) that no test of the feature names. For each id the model reads the requirement or invariant, finds the code that realises it, and writes a test of that behaviour naming the id, or adds the id to the test that already exercises it; it never writes production code, and an id the code does not realise is reported not-implemented for /appweaver implement. Only the lanes you work on, each confirmed first. The lane's tests then run — a failing new test gets at most two mechanical repairs, limited to the files this run wrote, and a failing assertion is reported as a suspected defect and stops the run — and test-citations runs again, so the script, not the model, says whether each id is now named."
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: "Optional — a CR id fills the test gaps of that open change's delta plans; with none, the master plans' gaps are filled."
+    required: false
+    bind: USER_INPUT
+
+scripts:
+  actions:
+    sh:  .appweaver/scripts/bash/aw-spec-actions.sh
+    ps1: .appweaver/scripts/powershell/aw-spec-actions.ps1
+  xref:
+    sh:  .appweaver/scripts/bash/aw-xref.sh
+    ps1: .appweaver/scripts/powershell/aw-xref.ps1
+
+# Sticky standards seed = the universal always-on rule only. Each lane's rule set is loaded
+# beside its own steps by tech-select, under implement's heading for that lane.
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+vars:
+  # master = the master plans' Traceability; delta = one open change's delta plans.
+  mode: "master"
+  cite_mode: "bootstrap"      # test-citations --mode
+  where_text: "the Traceability section"
+  spec_text: "spec.md, in context"
+  cr_id: ""
+  cr_arg: ""                  # " <CR-id>" on the delta path, for the commands this run names
+  cr_dir: ""
+  cr_lanes_csv: ""
+  matched_label: ""
+  open_ids: ""
+  preselect_hidden: ""
+  preselect_visible: "true"
+  delta_spec: ""
+  delta_model: ""
+  delta_backend_plan: ""
+  delta_backend_plan_exists: "false"
+  delta_frontend_plan: ""
+  delta_frontend_plan_exists: "false"
+  domain_model: ""
+  # THE LANES. A lane is a TARGET when it is worked here, has the plan this run reads, and —
+  # on a change — is one the change names. Each AND is an ordered assignment.
+  lanes_declared: "false"
+  be_working: "false"
+  fe_working: "false"
+  working_lane: ""
+  be_in_change: "true"        # every lane until cr-paths answers (and always on the master path)
+  fe_in_change: "true"
+  be_plan: ""
+  be_plan_ok: "false"
+  fe_plan: ""
+  fe_plan_ok: "false"
+  be_plan_needed: "false"
+  fe_plan_needed: "false"
+  be_target: "false"
+  fe_target: "false"
+  any_target: "false"
+  # WHAT THE SCRIPT FOUND, per lane, before this run wrote anything. Defaults read as "nothing
+  # to fill", so a lane that is not a target never asks and never generates.
+  be_all_cited: "true"
+  be_cite_checked: "true"
+  be_cite_clean: "true"
+  be_cite_warning: ""
+  be_advisory: "false"
+  be_uncited_before: "not checked — not a lane this run targets"
+  be_test_files: []
+  be_gap: "false"
+  fe_all_cited: "true"
+  fe_cite_checked: "true"
+  fe_cite_clean: "true"
+  fe_cite_warning: ""
+  fe_advisory: "false"
+  fe_uncited_before: "not checked — not a lane this run targets"
+  fe_test_files: []
+  fe_gap: "false"
+  any_gap: "false"
+  no_gap: "true"
+  # CONFIRMATION and generation.
+  be_answer: ""
+  be_go: "false"
+  fe_answer: ""
+  fe_go: "false"
+  any_go: "false"
+  be_existing_text: "  (not resolved)"
+  fe_existing_text: "  (not resolved)"
+  be_oracle_rule: "THE REQUIREMENT IS THE ORACLE: each test asserts what the requirement or invariant states. If the code does something else, the test fails, and that is a defect in the code — never a reason to bend the test."
+  fe_oracle_rule: "THE REQUIREMENT IS THE ORACLE: each test asserts what the requirement or invariant states. If the UI does something else, the test fails, and that is a defect in the code — never a reason to bend the test."
+  be_files: []
+  be_ids: "not run — this lane did not generate"
+  fe_files: []
+  fe_ids: "not run — this lane did not generate"
+  # THE TESTS AFTER WRITING. A lane that did not generate does not vote.
+  be_test_ok: "false"
+  be_test_ran: "true"
+  be_test_excerpt: ""
+  be_test_log: ""
+  be_no_setup: "false"
+  be_setup_reason: ""
+  be_setup_ok: "true"
+  be_repair_files: []
+  be_suspected: []
+  fe_test_ok: "false"
+  fe_test_ran: "true"
+  fe_test_excerpt: ""
+  fe_test_log: ""
+  fe_no_setup: "false"
+  fe_setup_reason: ""
+  fe_setup_ok: "true"
+  fe_repair_files: []
+  fe_suspected: []
+  be_tests_green: "not run — this lane did not generate"
+  be_tests_state: "not run — this lane did not generate"
+  fe_tests_green: "not run — this lane did not generate"
+  fe_tests_state: "not run — this lane did not generate"
+  be_uncited_after: "not checked — this lane did not generate"
+  be_after_cited: "false"
+  fe_uncited_after: "not checked — this lane did not generate"
+  fe_after_cited: "false"
+  # The verdict — votes raised by a lane that generated, refusing until its check answers.
+  be_tests_vote: "true"
+  fe_tests_vote: "true"
+  be_cite_vote: "true"
+  fe_cite_vote: "true"
+  tests_ok: "false"
+  cited_ok: "false"
+  after_next: "/appweaver analyze-slice — its fix loop repairs the code against the spec, or a test that is genuinely wrong"
+  okf_concept: ""
+
+workflow:
+
+  # 1. The active feature and its masters.
+  - id: feature_paths
+    action: execute_script
+    on_error: continue      # never crash raw on 'no feature set' — the gate below explains it
+    script: { ref: actions }
+    subcommand: feature-paths
+    outputs:
+      - { name: feature,              from: "$.feature" }
+      - { name: feature_dir,          from: "$.feature_dir" }
+      - { name: spec_file,            from: "$.spec_file" }
+      - { name: backend_plan,         from: "$.backend_plan" }
+      - { name: backend_plan_exists,  from: "$.backend_plan_exists" }
+      - { name: frontend_plan,        from: "$.frontend_plan" }
+      - { name: frontend_plan_exists, from: "$.frontend_plan_exists" }
+
+  - id: require_feature
+    action: verify_context
+    require_non_empty: feature_dir
+    on_empty: stop
+    on_empty_message: "No active feature. Run /appweaver select-feature first, then re-run fix-test-coverage."
+
+  - id: context_paths
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: context-paths
+    outputs:
+      - { name: domain_model, from: "$.domain_model" }
+
+  # 2. THE LANES this developer works on, read with --feature-dir so a lane the feature has
+  #    no surface in is not worked either.
+  - id: lanes
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: lane-resolve
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: lanes_declared, from: "$.declared" }
+      - { name: be_working,     from: "$.backend_working" }
+      - { name: be_lane_id,     from: "$.backend_lane_id" }
+      - { name: be_title,       from: "$.backend_title" }
+      - { name: be_language,    from: "$.backend_language" }
+      - { name: be_source_path, from: "$.backend_source_path" }
+      - { name: be_test_path,   from: "$.backend_test_path" }
+      - { name: fe_working,     from: "$.frontend_working" }
+      - { name: fe_lane_id,     from: "$.frontend_lane_id" }
+      - { name: fe_title,       from: "$.frontend_title" }
+      - { name: fe_language,    from: "$.frontend_language" }
+      - { name: fe_source_path, from: "$.frontend_source_path" }
+      - { name: fe_test_path,   from: "$.frontend_test_path" }
+      - { name: working_lane,   from: "$.working_lane" }
+
+  - id: require_lanes
+    action: verify_context
+    require_true: lanes_declared
+    on_false: stop
+    on_false_message: "No lane is declared in .appweaver/stacks.json, so there are no tests to write. Run /appweaver select-stack first."
+
+  # 3. WHICH RUN THIS IS — decided by the argument, not by the changes on disk. A CR id
+  #    selects that change; it must be open and name a lane you work on.
+  - id: mode_delta
+    condition: "{{USER_INPUT}}"
+    action: set
+    vars:
+      mode: "delta"
+      cite_mode: "delta"
+      where_text: "the ADDED / MODIFIED rows"
+      spec_text: "the change's delta-spec.md and its model delta, in context (the master spec.md and domain model too, for an id the change does not restate)"
+
+  - id: cr_list
+    condition: "{{mode}} == delta"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: cr-list
+    args: ["--feature-dir", "{{feature_dir}}", "--preselect", "{{USER_INPUT}}", "--lane", "{{working_lane}}"]
+    outputs:
+      - { name: matched_label,    from: "$.matched_label" }
+      - { name: open_ids,         from: "$.ids_csv" }
+      - { name: preselect_hidden, from: "$.preselect_hidden" }
+
+  - id: preselect_hidden_flag
+    condition: "{{preselect_hidden}} != "
+    action: set
+    vars: { preselect_visible: "false" }
+  - id: require_visible_change
+    action: verify_context
+    require_true: preselect_visible
+    on_false: stop
+    on_false_message: "Change {{preselect_hidden}} does not touch your working lane `{{working_lane}}` (.appweaver/lane.json): its **Lanes** line names only the other lane, so its tests are that lane's developer's to write. Run /appweaver select-lane to work on that lane."
+
+  - id: require_change
+    condition: "{{mode}} == delta"
+    action: verify_context
+    require_non_empty: matched_label
+    on_empty: stop
+    on_empty_message: "`{{USER_INPUT}}` is not an open change of {{feature}} that names your working lane `{{working_lane}}`. Open changes listed for you: {{open_ids}}. Pass one of them — or run /appweaver fix-test-coverage with no argument to fill the master plans' gaps."
+
+  # The change this run writes tests for becomes the ACTIVE one, as implement and
+  # analyze-slice-delta make it: build and the gates after it resolve the change from there.
+  - id: activate
+    condition: "{{mode}} == delta"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: cr-activate
+    args: ["--cr-id", "{{matched_label}}", "--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: active_change, from: "$.active_change" }
+
+  - id: cr_paths
+    condition: "{{mode}} == delta"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: cr-paths
+    args: ["--cr-id", "{{matched_label}}", "--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: cr_id,                      from: "$.cr_id" }
+      - { name: cr_dir,                     from: "$.cr_dir" }
+      - { name: delta_spec,                 from: "$.delta_spec" }
+      - { name: delta_model,                from: "$.delta_model" }
+      - { name: delta_backend_plan,         from: "$.delta_backend_plan" }
+      - { name: delta_backend_plan_exists,  from: "$.delta_backend_plan_exists" }
+      - { name: delta_frontend_plan,        from: "$.delta_frontend_plan" }
+      - { name: delta_frontend_plan_exists, from: "$.delta_frontend_plan_exists" }
+      - { name: cr_lanes_csv,               from: "$.lanes_csv" }
+      - { name: be_in_change,               from: "$.touches_backend" }
+      - { name: fe_in_change,               from: "$.touches_frontend" }
+  - id: cr_arg_set
+    condition: "{{mode}} == delta"
+    action: set
+    vars:
+      cr_arg: " {{cr_id}}"
+      after_next: "fix the code — /appweaver implement {{cr_id}} for behaviour that was never generated, or by hand — then /appweaver build and /appweaver analyze-slice-delta {{cr_id}}"
+
+  # 4. WHICH PLAN EACH LANE IS READ FROM, and which lanes are targets.
+  - id: be_plan_master
+    condition: "{{mode}} == master"
+    action: set
+    vars: { be_plan: "{{backend_plan}}", be_plan_ok: "{{backend_plan_exists}}" }
+  - id: be_plan_delta
+    condition: "{{mode}} == delta"
+    action: set
+    vars: { be_plan: "{{delta_backend_plan}}", be_plan_ok: "{{delta_backend_plan_exists}}" }
+  - id: fe_plan_master
+    condition: "{{mode}} == master"
+    action: set
+    vars: { fe_plan: "{{frontend_plan}}", fe_plan_ok: "{{frontend_plan_exists}}" }
+  - id: fe_plan_delta
+    condition: "{{mode}} == delta"
+    action: set
+    vars: { fe_plan: "{{delta_frontend_plan}}", fe_plan_ok: "{{delta_frontend_plan_exists}}" }
+
+  - id: be_needed_set
+    action: set
+    vars: { be_plan_needed: "{{be_working}}" }
+  - id: be_needed_not_in_change
+    condition: "{{be_in_change}} == false"
+    action: set
+    vars: { be_plan_needed: "false" }
+  - id: fe_needed_set
+    action: set
+    vars: { fe_plan_needed: "{{fe_working}}" }
+  - id: fe_needed_not_in_change
+    condition: "{{fe_in_change}} == false"
+    action: set
+    vars: { fe_plan_needed: "false" }
+  - id: be_target_set
+    condition: "{{be_plan_ok}} == true"
+    action: set
+    vars: { be_target: "{{be_plan_needed}}" }
+  - id: fe_target_set
+    condition: "{{fe_plan_ok}} == true"
+    action: set
+    vars: { fe_target: "{{fe_plan_needed}}" }
+
+  - id: warn_be_plan
+    condition: "{{be_plan_needed}} == true"
+    action: verify_context
+    require_true: be_plan_ok
+    on_false: continue
+    on_false_message: "NOTE — backend lane: there is no plan at {{be_plan}}, so there are no requirement ids to read for it. Author it with /appweaver plan{{cr_arg}}."
+  - id: warn_fe_plan
+    condition: "{{fe_plan_needed}} == true"
+    action: verify_context
+    require_true: fe_plan_ok
+    on_false: continue
+    on_false_message: "NOTE — frontend lane: there is no plan at {{fe_plan}}, so there are no requirement ids to read for it. Author it with /appweaver plan{{cr_arg}}."
+
+  - id: any_target_be
+    condition: "{{be_target}} == true"
+    action: set
+    vars: { any_target: "true" }
+  - id: any_target_fe
+    condition: "{{fe_target}} == true"
+    action: set
+    vars: { any_target: "true" }
+  - id: require_a_target
+    action: verify_context
+    require_true: any_target
+    on_false: stop
+    on_false_message: "No lane to fill tests for. A lane is one when you work on it (`{{working_lane}}`, .appweaver/lane.json), it has the plan this run reads and — for a change — the change names it (it names `{{cr_lanes_csv}}`). Backend: worked {{be_working}}, plan {{be_plan_ok}}; frontend: worked {{fe_working}}, plan {{fe_plan_ok}}. Run /appweaver plan{{cr_arg}} for a lane with no plan, or /appweaver select-lane to work on another lane."
+
+  # 5. THE GAP, per target lane — the same check the gates run. The slice's files come from
+  #    its OKF concept; the check keeps the tests among them inside each lane's folders.
+  - id: concept_paths
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: slice_files, from: "$.paths" }
+
+  - id: cite_backend
+    condition: "{{be_target}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{be_plan}}", "--kind", "backend", "--mode", "{{cite_mode}}", "--paths", "{{slice_files}}", "--source-path", "{{be_source_path}}", "--test-path", "{{be_test_path}}", "--spec", "{{spec_file}}", "--model", "{{domain_model}}"]
+    outputs:
+      - { name: be_all_cited,      from: "$.all_cited" }
+      - { name: be_cite_checked,   from: "$.checked" }
+      - { name: be_cite_clean,     from: "$.clean" }
+      - { name: be_cite_warning,   from: "$.warning" }
+      - { name: be_advisory,       from: "$.advisory" }
+      - { name: be_uncited_before, from: "$.uncited_text" }
+      - { name: be_test_files,     from: "$.test_files" }
+  - id: cite_frontend
+    condition: "{{fe_target}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{fe_plan}}", "--kind", "frontend", "--mode", "{{cite_mode}}", "--paths", "{{slice_files}}", "--source-path", "{{fe_source_path}}", "--test-path", "{{fe_test_path}}", "--spec", "{{spec_file}}", "--model", "{{domain_model}}"]
+    outputs:
+      - { name: fe_all_cited,      from: "$.all_cited" }
+      - { name: fe_cite_checked,   from: "$.checked" }
+      - { name: fe_cite_clean,     from: "$.clean" }
+      - { name: fe_cite_warning,   from: "$.warning" }
+      - { name: fe_advisory,       from: "$.advisory" }
+      - { name: fe_uncited_before, from: "$.uncited_text" }
+      - { name: fe_test_files,     from: "$.test_files" }
+
+  # A plan the check could not read (no Traceability section, no ADDED / MODIFIED rows) is
+  # said here; the gap list itself is put to you in the question below.
+  - id: warn_be_unchecked
+    condition: "{{be_cite_checked}} == false"
+    action: verify_context
+    require_true: be_cite_clean
+    on_false: continue
+    on_false_message: "{{be_cite_warning}}"
+  - id: warn_fe_unchecked
+    condition: "{{fe_cite_checked}} == false"
+    action: verify_context
+    require_true: fe_cite_clean
+    on_false: continue
+    on_false_message: "{{fe_cite_warning}}"
+
+  - id: be_gap_set
+    condition: "{{be_all_cited}} == false"
+    action: set
+    vars: { be_gap: "true", any_gap: "true", no_gap: "false" }
+  - id: fe_gap_set
+    condition: "{{fe_all_cited}} == false"
+    action: set
+    vars: { fe_gap: "true", any_gap: "true", no_gap: "false" }
+  - id: note_nothing_to_fill
+    action: verify_context
+    require_true: any_gap
+    on_false: continue
+    on_false_message: "Nothing to fill — every FR- and BR- id in {{where_text}} of each lane's plan is already named by a test of {{feature}}."
+
+  # An adopted feature's tests are judged by what its spec was found to say.
+  - id: be_oracle_reversed
+    condition: "{{be_advisory}} == true"
+    action: set
+    vars: { be_oracle_rule: "THIS PLAN WAS REVERSE-ENGINEERED from the existing code (origin: reverse-engineered), so the spec describes what the code was found to do: each test asserts what the spec states, and is expected to pass. One that fails is a mismatch between the adopted spec and the code — report it, and never change the code or bend the assertion to make it pass." }
+  - id: fe_oracle_reversed
+    condition: "{{fe_advisory}} == true"
+    action: set
+    vars: { fe_oracle_rule: "THIS PLAN WAS REVERSE-ENGINEERED from the existing UI code (origin: reverse-engineered), so the spec describes what the code was found to do: each test asserts what the spec states, and is expected to pass. One that fails is a mismatch between the adopted spec and the code — report it, and never change the code or bend the assertion to make it pass." }
+
+  # 6. CONFIRM EACH LANE before anything is written, with the ids in front of you.
+  - id: ask_backend
+    condition: "{{be_gap}} == true"
+    action: ask
+    prompt: "Write the missing tests for the BACKEND lane now? Lane `{{be_lane_id}}` — {{be_title}}, {{be_language}}. No test of {{feature}} names {{be_uncited_before}} ({{where_text}} of {{be_plan}}). Tests go under {{be_test_path}}; production code is not touched."
+    options: ["yes", "no"]
+    answer_var: be_answer
+  - id: be_go_set
+    condition: "{{be_answer}} == yes"
+    action: set
+    vars: { be_go: "{{be_gap}}", any_go: "true" }
+  - id: ask_frontend
+    condition: "{{fe_gap}} == true"
+    action: ask
+    prompt: "Write the missing tests for the FRONTEND lane now? Lane `{{fe_lane_id}}` — {{fe_title}}, {{fe_language}}. No test of {{feature}} names {{fe_uncited_before}} ({{where_text}} of {{fe_plan}}). Tests go under {{fe_test_path}}; production code is not touched."
+    options: ["yes", "no"]
+    answer_var: fe_answer
+  - id: fe_go_set
+    condition: "{{fe_answer}} == yes"
+    action: set
+    vars: { fe_go: "{{fe_gap}}", any_go: "true" }
+
+  - id: resolve_pre_hooks
+    condition: "{{any_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_fix_test_coverage"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    condition: "{{any_go}} == true"
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # ═══════════════════════════════ BACKEND LANE ═══════════════════════════════
+  # The lane's files, as a path list the generation step reads with its tools.
+  - id: be_existing_code
+    condition: "{{be_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{be_source_path}}", "--under", "{{be_test_path}}"]
+    outputs:
+      - { name: be_existing_text, from: "$.paths_text" }
+  - id: tech_select
+    condition: "{{be_go}} == true"
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-implement-backend }
+  - id: ctx_backend
+    condition: "{{be_go}} == true"
+    action: build_context
+    context:
+      - { path: "{{be_plan}}" }                        # THE MAP — which element realises each id
+      - { path: "{{delta_spec}}", optional: true }     # a change's requirement text (delta path only)
+      - { path: "{{delta_model}}", optional: true }    # the invariants a change adds (delta path only)
+      - { path: "{{spec_file}}", optional: true }      # THE ORACLE — what each FR- states
+      - { path: "{{domain_model}}", optional: true }   # what each BR- states, and the names the domain uses
+  - id: gen_backend
+    condition: "{{be_go}} == true"
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      WRITE THE MISSING TESTS for the `{{be_lane_id}}` lane ({{be_title}}, {{be_language}})
+      of {{feature}}. No test of this feature names these requirement ids:
+      {{be_uncited_before}}. They come from {{where_text}} of {{be_plan}} (in context). What
+      each one states is in {{spec_text}} — an FR- in the spec, a BR- in the domain model.
+      {{be_oracle_rule}}
+      The lane's files — READ the ones you need:
+      {{be_existing_text}}
+      The feature's existing tests: {{be_test_files}}
+
+      For EACH id:
+      1. Read what it states, and find the code that realises it — the plan maps the id to
+         its element(s).
+      2. If a test of this feature already exercises exactly what the id states, NAME THE ID
+         in that test — its name, a comment, an attribute or a tag — and write no second
+         test. Report it `annotated`.
+      3. Otherwise WRITE a test that exercises what the id states — the behaviour, the rule,
+         the error it names — and asserts the outcome the text gives. Name the id in it as
+         `FR-004`, `FR_004` or `FR004`, whichever this language allows. Report it `written`.
+      4. If the code does not realise the requirement at all, write NO test for it: a test
+         against missing behaviour either passes without checking anything or fails for a
+         reason no test can fix. Report it `not-implemented` — generating the code is
+         /appweaver implement's job.
+      Rules:
+      - TESTS ONLY. Never create, edit or delete production code. Tests go under
+        `{{be_test_path}}`, in the framework, layout and naming this feature's existing
+        tests use. The one edit allowed outside it: registering a new test project in the
+        file the lane's test command discovers tests through (e.g. a .NET solution file).
+      - Never weaken, delete or rewrite an existing test; adding an id to one is the only
+        change allowed to it.
+      - Use the domain model's names for entities, fields and states.
+      - Report every listed id in an `ids` list in your closing JSON block, spelled as
+        listed: {"id": "<id>", "status": "written" | "annotated" | "not-implemented" |
+        "blocked", "test": "<file>", "reason": "<why, when not written or annotated>"}.
+    outputs:
+      - { name: be_files, from: "$.files" }
+      - { name: be_ids,   from: "$.ids" }
+  - id: be_ids_none
+    condition: "{{be_ids}} == "
+    action: set
+    vars: { be_ids: "(none reported)" }
+
+  - id: be_tests
+    condition: "{{be_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-run
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "backend"]
+    outputs:
+      - { name: be_test_ok,      from: "$.fence_green" }
+      - { name: be_test_ran,     from: "$.ran" }
+      - { name: be_test_excerpt, from: "$.failing_excerpt" }
+      - { name: be_test_log,     from: "$.log_tail" }
+      - { name: be_no_setup,     from: "$.no_setup" }
+      - { name: be_setup_reason, from: "$.setup_reason" }
+
+  # AT MOST TWO MECHANICAL REPAIRS, each re-run. A lane with no test setup has nothing a
+  # repair can help, and a pass that changed nothing has nothing left to try.
+  - id: be_repair_loop
+    condition: "{{be_go}} == true"
+    action: loop
+    while: "{{be_test_ok}} != true"
+    max_iterations: 2
+    steps:
+      - id: be_no_setup_break
+        action: break
+        condition: "{{be_no_setup}} == true"
+      - id: be_repair
+        action: agent_generate
+        tools: "Read,Write,Edit"
+        permission_mode: acceptEdits
+        task: |
+          THE TESTS DO NOT PASS after the missing tests were written for the
+          `{{be_lane_id}}` lane. Failing lines (each labelled with its command and exit code):
+          {{be_test_excerpt}}
+          Log tail: {{be_test_log}}
+          You may change ONLY the files this run wrote or annotated: {{be_files}}.
+          Repair what is MECHANICAL in them — a test that does not compile, a missing import,
+          the wrong fixture, setup, constructor or path. Never change production code, never
+          touch another test, and never change what an assertion EXPECTS: the expected
+          outcome comes from the requirement's text.
+          {{be_oracle_rule}}
+          A test that runs and fails its ASSERTION has found a place where the code does not
+          do what the requirement says: leave it as it is and report it in a
+          `suspected_defects` list in your closing JSON block — {"id": "<id>", "test":
+          "<file>", "failure": "<what was expected, and what happened>"}. A failure in a test
+          this run did not write is not yours to repair; say so. If no failure is mechanical,
+          change nothing.
+        outputs:
+          - { name: be_repair_files, from: "$.files" }
+          - { name: be_suspected,    from: "$.suspected_defects" }
+      - id: be_repair_idle_break
+        action: break
+        condition: "{{be_repair_files}} == []"
+      - id: be_retest
+        action: execute_script
+        on_error: continue
+        script: { ref: actions }
+        subcommand: test-run
+        args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "backend"]
+        outputs:
+          - { name: be_test_ok,      from: "$.fence_green" }
+          - { name: be_test_ran,     from: "$.ran" }
+          - { name: be_test_excerpt, from: "$.failing_excerpt" }
+          - { name: be_test_log,     from: "$.log_tail" }
+
+  - id: warn_be_not_run
+    condition: "{{be_go}} == true"
+    action: verify_context
+    require_true: be_test_ran
+    on_false: continue
+    on_false_message: "NOTE — the backend lane declares no test command, so the tests just written were not run. Their citations are checked; whether they pass is not."
+  - id: be_setup_ok_flag
+    condition: "{{be_no_setup}} == true"
+    action: set
+    vars: { be_setup_ok: "false" }
+  - id: warn_be_no_setup
+    condition: "{{be_go}} == true"
+    action: verify_context
+    require_true: be_setup_ok
+    on_false: continue
+    on_false_message: "WARNING — the backend lane's test command found nothing to run ({{be_setup_reason}}), so the tests just written were not run. Wire up the lane's tests (the runner or test project its command expects, or the command in .appweaver/stacks.json); analyze-slice fails a slice with no tests to run."
+
+  # The tests join the feature's concept, so the gates read them as this feature's own.
+  - id: be_concept
+    condition: "{{be_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{be_files}}", "--merge"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
+
+  - id: be_recheck
+    condition: "{{be_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{be_plan}}", "--kind", "backend", "--mode", "{{cite_mode}}", "--paths", "{{slice_files}}", "--paths", "{{be_files}}", "--source-path", "{{be_source_path}}", "--test-path", "{{be_test_path}}", "--spec", "{{spec_file}}", "--model", "{{domain_model}}"]
+    outputs:
+      - { name: be_after_cited,   from: "$.all_cited" }
+      - { name: be_uncited_after, from: "$.uncited_text" }
+
+  # ═══════════════════════════════ FRONTEND LANE ══════════════════════════════
+  # Its rules REPLACE the backend's, so each lane's tests are written under its own set.
+  - id: fe_existing_code
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{fe_source_path}}", "--under", "{{fe_test_path}}"]
+    outputs:
+      - { name: fe_existing_text, from: "$.paths_text" }
+  - id: tech_select_ui
+    condition: "{{fe_go}} == true"
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-implement-frontend, replace: "true" }
+  - id: ctx_frontend
+    condition: "{{fe_go}} == true"
+    action: build_context
+    context:
+      - { path: "{{fe_plan}}" }
+      - { path: "{{delta_spec}}", optional: true }
+      - { path: "{{delta_model}}", optional: true }
+      - { path: "{{spec_file}}", optional: true }
+      - { path: "{{domain_model}}", optional: true }
+  - id: gen_frontend
+    condition: "{{fe_go}} == true"
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      WRITE THE MISSING TESTS for the `{{fe_lane_id}}` lane ({{fe_title}}, {{fe_language}})
+      of {{feature}}. No test of this feature names these requirement ids:
+      {{fe_uncited_before}}. They come from {{where_text}} of {{fe_plan}} (in context). What
+      each one states is in {{spec_text}} — an FR- in the spec, a BR- in the domain model.
+      {{fe_oracle_rule}}
+      The lane's files — READ the ones you need:
+      {{fe_existing_text}}
+      The feature's existing tests: {{fe_test_files}}
+
+      For EACH id:
+      1. Read what it states, and find the screen, component, state or binding that
+         realises it — the plan maps the id to its element(s).
+      2. If a test of this feature already exercises exactly what the id states, NAME THE ID
+         in that test — its name, a comment, an attribute or a tag — and write no second
+         test. Report it `annotated`.
+      3. Otherwise WRITE a test that exercises what the id states — the interaction, the
+         state the user sees, the rule the UI enforces for feedback — and asserts the
+         outcome the text gives. A snapshot alone is not a test. Name the id in it as
+         `FR-004`, `FR_004` or `FR004`, whichever this language allows. Report it `written`.
+      4. If the UI does not realise the requirement at all, write NO test for it and report
+         it `not-implemented` — generating the code is /appweaver implement's job.
+      Rules:
+      - TESTS ONLY. Never create, edit or delete production code, the app shell, the global
+        layout or the design system. Tests go under `{{fe_test_path}}`, in the framework,
+        layout and naming this feature's existing tests use.
+      - Never weaken, delete or rewrite an existing test; adding an id to one is the only
+        change allowed to it.
+      - Labels, states and messages in an assertion use the domain model's ubiquitous
+        language.
+      - Report every listed id in an `ids` list in your closing JSON block, spelled as
+        listed: {"id": "<id>", "status": "written" | "annotated" | "not-implemented" |
+        "blocked", "test": "<file>", "reason": "<why, when not written or annotated>"}.
+    outputs:
+      - { name: fe_files, from: "$.files" }
+      - { name: fe_ids,   from: "$.ids" }
+  - id: fe_ids_none
+    condition: "{{fe_ids}} == "
+    action: set
+    vars: { fe_ids: "(none reported)" }
+
+  - id: fe_tests
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-run
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "frontend"]
+    outputs:
+      - { name: fe_test_ok,      from: "$.fence_green" }
+      - { name: fe_test_ran,     from: "$.ran" }
+      - { name: fe_test_excerpt, from: "$.failing_excerpt" }
+      - { name: fe_test_log,     from: "$.log_tail" }
+      - { name: fe_no_setup,     from: "$.no_setup" }
+      - { name: fe_setup_reason, from: "$.setup_reason" }
+
+  - id: fe_repair_loop
+    condition: "{{fe_go}} == true"
+    action: loop
+    while: "{{fe_test_ok}} != true"
+    max_iterations: 2
+    steps:
+      - id: fe_no_setup_break
+        action: break
+        condition: "{{fe_no_setup}} == true"
+      - id: fe_repair
+        action: agent_generate
+        tools: "Read,Write,Edit"
+        permission_mode: acceptEdits
+        task: |
+          THE TESTS DO NOT PASS after the missing tests were written for the
+          `{{fe_lane_id}}` lane. Failing lines (each labelled with its command and exit code):
+          {{fe_test_excerpt}}
+          Log tail: {{fe_test_log}}
+          You may change ONLY the files this run wrote or annotated: {{fe_files}}.
+          Repair what is MECHANICAL in them — a test that does not compile, a missing import,
+          the wrong render setup, mock, provider or path. Never change production code, never
+          touch another test, and never change what an assertion EXPECTS: the expected
+          outcome comes from the requirement's text.
+          {{fe_oracle_rule}}
+          A test that runs and fails its ASSERTION has found a place where the UI does not do
+          what the requirement says: leave it as it is and report it in a
+          `suspected_defects` list in your closing JSON block — {"id": "<id>", "test":
+          "<file>", "failure": "<what was expected, and what happened>"}. A failure in a test
+          this run did not write is not yours to repair; say so. If no failure is mechanical,
+          change nothing.
+        outputs:
+          - { name: fe_repair_files, from: "$.files" }
+          - { name: fe_suspected,    from: "$.suspected_defects" }
+      - id: fe_repair_idle_break
+        action: break
+        condition: "{{fe_repair_files}} == []"
+      - id: fe_retest
+        action: execute_script
+        on_error: continue
+        script: { ref: actions }
+        subcommand: test-run
+        args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "frontend"]
+        outputs:
+          - { name: fe_test_ok,      from: "$.fence_green" }
+          - { name: fe_test_ran,     from: "$.ran" }
+          - { name: fe_test_excerpt, from: "$.failing_excerpt" }
+          - { name: fe_test_log,     from: "$.log_tail" }
+
+  - id: warn_fe_not_run
+    condition: "{{fe_go}} == true"
+    action: verify_context
+    require_true: fe_test_ran
+    on_false: continue
+    on_false_message: "NOTE — the frontend lane declares no test command, so the tests just written were not run. Their citations are checked; whether they pass is not."
+  - id: fe_setup_ok_flag
+    condition: "{{fe_no_setup}} == true"
+    action: set
+    vars: { fe_setup_ok: "false" }
+  - id: warn_fe_no_setup
+    condition: "{{fe_go}} == true"
+    action: verify_context
+    require_true: fe_setup_ok
+    on_false: continue
+    on_false_message: "WARNING — the frontend lane's test command found nothing to run ({{fe_setup_reason}}), so the tests just written were not run. Wire up the lane's tests (the runner its command expects, or the command in .appweaver/stacks.json); analyze-slice fails a slice with no tests to run."
+
+  - id: fe_concept
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{fe_files}}", "--merge"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
+
+  - id: fe_recheck
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{fe_plan}}", "--kind", "frontend", "--mode", "{{cite_mode}}", "--paths", "{{slice_files}}", "--paths", "{{fe_files}}", "--source-path", "{{fe_source_path}}", "--test-path", "{{fe_test_path}}", "--spec", "{{spec_file}}", "--model", "{{domain_model}}"]
+    outputs:
+      - { name: fe_after_cited,   from: "$.all_cited" }
+      - { name: fe_uncited_after, from: "$.uncited_text" }
+
+  # ════════════════════════════════ THE VERDICT ════════════════════════════════
+  # Each generating lane votes its test result and its re-check; a lane that did not
+  # generate does not vote.
+  - id: be_tests_vote_set
+    condition: "{{be_go}} == true"
+    action: set
+    vars:
+      be_tests_vote: "{{be_test_ok}}"
+      be_cite_vote: "{{be_after_cited}}"
+      be_tests_green: "{{be_test_ok}}"
+      be_tests_state: "green={{be_test_ok}} · failing lines: {{be_test_excerpt}} · suspected defects: {{be_suspected}}"
+  - id: fe_tests_vote_set
+    condition: "{{fe_go}} == true"
+    action: set
+    vars:
+      fe_tests_vote: "{{fe_test_ok}}"
+      fe_cite_vote: "{{fe_after_cited}}"
+      fe_tests_green: "{{fe_test_ok}}"
+      fe_tests_state: "green={{fe_test_ok}} · failing lines: {{fe_test_excerpt}} · suspected defects: {{fe_suspected}}"
+  # Tests that could not run were said above; they are not a failing suite.
+  - id: be_tests_vote_no_setup
+    condition: "{{be_setup_ok}} == false"
+    action: set
+    vars: { be_tests_vote: "true" }
+  - id: fe_tests_vote_no_setup
+    condition: "{{fe_setup_ok}} == false"
+    action: set
+    vars: { fe_tests_vote: "true" }
+  - id: verdict_seed
+    action: set
+    vars: { tests_ok: "true", cited_ok: "true" }
+  - id: tests_clear_backend
+    condition: "{{be_tests_vote}} != true"
+    action: set
+    vars: { tests_ok: "false" }
+  - id: tests_clear_frontend
+    condition: "{{fe_tests_vote}} != true"
+    action: set
+    vars: { tests_ok: "false" }
+  - id: cited_clear_backend
+    condition: "{{be_cite_vote}} != true"
+    action: set
+    vars: { cited_ok: "false" }
+  - id: cited_clear_frontend
+    condition: "{{fe_cite_vote}} != true"
+    action: set
+    vars: { cited_ok: "false" }
+
+  # A RED SUITE FIRST: a failing assertion is a finding about the code, and it is the more
+  # important of the two.
+  - id: tests_gate
+    action: verify_context
+    require_true: tests_ok
+    on_false: stop
+    on_false_message: >
+      The tests do not pass after the missing ones were written and repaired as far as a
+      test may be. Backend: {{be_tests_state}}. Frontend: {{fe_tests_state}}. A suspected defect is a new test that runs and
+      fails its assertion — the code does not do what the requirement says. The tests are
+      kept as the evidence. Next: {{after_next}}. For an adopted feature, a failing assertion
+      is a mismatch between its spec and its code: correct the spec through a change
+      (/appweaver specify), never the code to match a test.
+
+  - id: cited_gate
+    action: verify_context
+    require_true: cited_ok
+    on_false: stop
+    on_false_message: >
+      Still named by no test after this run — backend: {{be_uncited_after}}; frontend:
+      {{fe_uncited_after}}. What the model reported per id — backend: {{be_ids}};
+      frontend: {{fe_ids}}. An id reported not-implemented has no code to test:
+      /appweaver implement{{cr_arg}} generates it, then run /appweaver
+      fix-test-coverage{{cr_arg}} again. For any other id, run this again or name the id in
+      the test that exercises it by hand.
+
+  - id: resolve_post_hooks
+    condition: "{{any_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_fix_test_coverage"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    condition: "{{any_go}} == true"
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  feature_dir: "{{feature_dir}}"
+  mode: "{{mode}}"                       # master | delta
+  cr_id: "{{cr_id}}"
+  working_lane: "{{working_lane}}"
+  # Per lane: the ids no test named before this run, what the model reported for each, and
+  # what the script found after it. `none` after = every id is now named by a test.
+  backend_uncited_before: "{{be_uncited_before}}"
+  backend_ids: "{{be_ids}}"
+  backend_files: "{{be_files}}"
+  backend_tests_green: "{{be_tests_green}}"
+  backend_suspected_defects: "{{be_suspected}}"
+  backend_uncited_after: "{{be_uncited_after}}"
+  frontend_uncited_before: "{{fe_uncited_before}}"
+  frontend_ids: "{{fe_ids}}"
+  frontend_files: "{{fe_files}}"
+  frontend_tests_green: "{{fe_tests_green}}"
+  frontend_suspected_defects: "{{fe_suspected}}"
+  frontend_uncited_after: "{{fe_uncited_after}}"
+  okf_concept: "{{okf_concept}}"
+  next: "MASTER (no argument): /appweaver analyze-slice — it re-runs the tests and checks every FR- and BR- the plans trace is named by a test. CHANGE (a CR id): /appweaver build, then /appweaver analyze-slice-delta {{cr_id}}. Review the new tests with git diff either way: the script proves each id is named and the suite is green, not that a test asserts what its requirement says."