aw-spec-cli 0.1.33 → 0.1.35

package/assets/.appweaver/orchestrator/workflows/aw-spec-analyze-slice-delta.orch.yaml

@@ -53,7 +53,8 @@
 # lane rule set, no constitution, no stack binding — which is the same reason analyze-plan
 # stops naming `/appweaver plan` instead of filling an empty template itself. So every
 # finding is REPORTED with the command that closes it (implement for missing code, plan for
-# a delta plan that is wrong, specify for a spec or model gap) and the gate stops. The
+# a delta plan that is wrong, specify for a spec or model gap, fix-test-coverage for a
+# requirement no test names) and the gate stops. The
 # repair loops stay in analyze-slice, where the merged master is the anchor and the job is
 # fixing what is BROKEN rather than building what is ABSENT.
 #
@@ -73,6 +74,29 @@
 # way: a developer working one lane of two writes delta-slice-analyze-report.<lane>.md, and
 # a developer on every lane writes delta-slice-analyze-report.md.
 #
+# EVERY REQUIREMENT THE CHANGE'S PLAN SERVES IS NAMED BY A TEST — checked by a script as
+# well as by the model. Check 2 asks the model whether each ADDED or MODIFIED item has a
+# test citing its id; `test-citations` answers the same question deterministically for the
+# FR- and BR- ids each gated lane's delta plan rows serve (ADDED, MODIFIED, model changes,
+# interaction states — removed rows aside), over the slice's test files. An id no test
+# names fails that lane's requirement vote and joins its findings, so it is stamped and
+# reported like the model's own, and routed to /appweaver fix-test-coverage <CR-id> — the
+# workflow that writes the missing tests; one the model already reported as untested is not
+# reported twice. analyze-slice runs the master-plan half of this after the merge, but the
+# change's new ids reach the master plans only when plan re-derives them, so this is where
+# they are checked.
+#
+# THE SERVICE SERVES THE CHANGE'S API AS ITS DELTA API PLAN DRAFTS IT — checked by a script
+# too. The frontend lane binds to the change's API draft (changes/<CR-id>/api-draft.json,
+# drafted from delta-api-plan.md, or from the delta backend plan of a change planned before
+# delta API plans existed) while the change is open, so for a gated service lane the
+# service's as-built document is written the way the lane says and compared with it
+# (contract-verify --cr): an endpoint the change adds or changes that is not served as
+# drafted, or one it removes that is still served, fails that lane's requirement vote and
+# joins its findings, routed to implement. A field that differs is reported. A lane that sets
+# no way to write its document is not checked, and the run says so. A change that drafts no
+# API change is not checked either, and its document is not written.
+#
 # NO NEW RULE-MAP HEADING. It loads `## /aw-spec-analyze-slice` — the same testing +
 # coding-standards set its master twin reads — so no project has to add configuration to
 # get this gate. The DOMAIN gate overlays are deliberately NOT loaded: full domain
@@ -86,8 +110,8 @@
 # =============================================================================
 
 name: aw-spec-analyze-slice-delta
-version: 1.3.0
-description: "The delta-spec↔delta-code gate — verify that the open change DOES WHAT IT WAS ASKED TO DO, before it reaches the master documents. delta-spec.md is the anchor, exactly as it is for analyze-plan-delta. Asks which open change it is gating (only the changes naming a lane you work on are listed) and gates only the lanes the change names that you work on. Each gated lane runs its own tests (the first execution on the change path, since build only compiles), then its code and paired tests are evaluated against the change's REQUIREMENTS — every ADDED or MODIFIED delta-spec item realised in code, every one covered by a test that cites its id, every invariant the model delta adds actually enforced — with the delta plan in context as the map from requirement to code and cross-checked in its own right, so an element the plan promised and nobody built is caught too. Each gated lane's pass or fail is recorded in the change as .aw-slice-gate.<lane>.json. The dynamic twin of analyze-plan-delta and the delta twin of analyze-slice, which cannot see a missing implementation because a behaviour that was never built leaves no failing test. Verify-only — it reports each finding with the command that closes it and stops; it generates no code and repairs nothing."
+version: 1.7.0
+description: "The delta-spec↔delta-code gate — verify that the open change DOES WHAT IT WAS ASKED TO DO, before it reaches the master documents. delta-spec.md is the anchor, exactly as it is for analyze-plan-delta. Asks which open change it is gating (only the changes naming a lane you work on are listed) and gates only the lanes the change names that you work on. Each gated lane runs its own tests (the first execution on the change path, since build only compiles), then its code and paired tests are evaluated against the change's REQUIREMENTS — every ADDED or MODIFIED delta-spec item realised in code, every one covered by a test that cites its id (and, by script, every FR- and BR- the lane's delta plan rows serve named by a test of the slice), the service lane serving the API the change's delta API plan drafts (by script, against its as-built document), every invariant the model delta adds actually enforced — with the delta plan in context as the map from requirement to code and cross-checked in its own right, so an element the plan promised and nobody built is caught too. Each gated lane's pass or fail is recorded in the change as .aw-slice-gate.<lane>.json. The dynamic twin of analyze-plan-delta and the delta twin of analyze-slice, which cannot see a missing implementation because a behaviour that was never built leaves no failing test. Verify-only — it reports each finding with the command that closes it and stops; it generates no code and repairs nothing."
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -124,6 +148,8 @@ vars:
   delta_backend_plan_exists: "false"
   delta_frontend_plan: ""
   delta_frontend_plan_exists: "false"
+  delta_api_plan: ""           # the change's API — absent for a change whose delta backend plan carries it
+  api_plan: ""                 # the feature's API plan — absent for a feature whose backend plan carries it
   domain_model: ""
   # WHICH LANES THIS GATE CHECKS — a lane is gated when it is DECLARED for this feature, the
   # change's **Lanes** line NAMES it, this developer WORKS on it (.appweaver/lane.json) and
@@ -191,6 +217,39 @@ vars:
   be_req_vote: "true"
   fe_req_vote: "true"
   requirements_ok: "false"
+  # The test-citation check, per gated lane. Its `ok` votes into that lane's requirement
+  # vote only when the lane is gated, and a check that never answered votes not met.
+  be_cite_ok: "false"
+  be_cite_clean: "false"
+  be_cite_warning: ""
+  be_uncited: "not checked — the lane is not gated"
+  be_cite_findings: []
+  be_cite_vote: "true"
+  fe_cite_ok: "false"
+  fe_cite_clean: "false"
+  fe_cite_warning: ""
+  fe_uncited: "not checked — the lane is not gated"
+  fe_cite_findings: []
+  fe_cite_vote: "true"
+  # The API check of a gated service lane — the same refusing default as the citation
+  # check, voting only when its document was written, and only for a change that drafts an
+  # API change.
+  be_api_needed: "false"       # contract-verify --cr --check: the change drafts something to check
+  be_api_plan_note: ""         # why it drafts nothing, when it does not
+  be_api_way: ""
+  be_api_placeholder: ""
+  be_api_export_ok: "false"
+  be_api_export_reason: ""
+  be_api_export_log: ""
+  be_api_has_way: "true"
+  be_api_export_vote: "true"
+  be_api_export_clean: "true"
+  be_api_ok: ""
+  be_api_issues: "not checked — no as-built API document was written in this run"
+  be_api_warning: ""
+  be_api_clean: "true"
+  be_api_findings: []
+  be_api_vote: "true"
   # Findings split by the command that closes them (gap-route). Defaults read as
   # "nothing found", so a run where the router could not execute still prints.
   gap_summary: "no findings"
@@ -201,6 +260,8 @@ vars:
   fix_plan_n: "0"
   fix_spec: "none"
   fix_spec_n: "0"
+  fix_tests: "none"
+  fix_tests_n: "0"
   fix_review: "none"
   fix_review_n: "0"
   gate_ok: "false"
@@ -253,6 +314,7 @@ workflow:
       - { name: spec_file,     from: "$.spec_file" }
       - { name: backend_plan,  from: "$.backend_plan" }
       - { name: frontend_plan, from: "$.frontend_plan" }
+      - { name: api_plan,      from: "$.api_plan" }
 
   # THIS FEATURE'S LANES. lane_resolve above read the REPO's declaration; one feature may
   # own no part of a lane's surface — adopt records `lanes: [backend]` in
@@ -354,6 +416,7 @@ workflow:
       - { 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: delta_api_plan,            from: "$.delta_api_plan" }
       - { name: wave,                      from: "$.wave" }
       - { name: domain_model,              from: "$.domain_model" }
       # The lanes this change touches — its delta-spec's **Lanes** line, every lane when it
@@ -557,8 +620,10 @@ workflow:
       - { path: "{{delta_spec}}", optional: true }   # THE ANCHOR — what this change was asked to do
       - { path: "{{delta_model}}", optional: true }  # the invariants it adds or changes — requirements too
       - { path: "{{delta_backend_plan}}" }           # THE MAP — which element serves which requirement
+      - { path: "{{delta_api_plan}}", optional: true } # the change's API — the endpoints it adds, changes or removes, and their error contracts
       - { path: "{{spec_file}}", optional: true }    # the master spec — the EXISTING ids a plan-only change still serves
       - { path: "{{backend_plan}}", optional: true } # the master plan — what was already there
+      - { path: "{{api_plan}}", optional: true }     # the master API plan — the endpoints as they were
       - { path: "{{domain_model}}", optional: true } # the model as it stands before the merge
   - id: check_backend
     condition: "{{be_gated}} == true"
@@ -573,14 +638,15 @@ workflow:
       not "does it match the plan": it is DOES THIS CHANGE DO WHAT IT WAS ASKED TO DO?
       {{source_count}} file(s) realise this slice: {{source_files}} — READ the ones this
       change should have touched.
-      The delta plan is in context as the MAP from a requirement to the element that serves
-      it — use it to know WHERE to look, and to write a finding that names the place the
+      The delta plan — with the change's delta-api-plan.md, in context where it has one —
+      is in context as the MAP from a requirement to the element or endpoint that serves
+      it: use it to know WHERE to look, and to write a finding that names the place the
       behaviour was supposed to land. It is not the authority: a requirement the plan never
       planned is still this gate's finding, because the delta spec is the only document
       that knows it was asked for.
-      The master spec, master plan and master domain model are what was ALREADY there; they
-      do not yet carry this change (finalize-delta merges it AFTER this gate), so never
-      report an element as missing from them.
+      The master spec, master plan, master API plan and master domain model are what was
+      ALREADY there; they do not yet carry this change (finalize-delta merges it AFTER this
+      gate), so never report an element as missing from them.
 
       CHECK 1 — REQUIREMENTS → CODE (the reason this gate exists). For EVERY ADDED or
       MODIFIED item in the delta-spec — FR-, BR-, CN-, DC-, IC-, user story — the code must
@@ -608,7 +674,9 @@ workflow:
 
       CHECK 3 — THE PLAN'S OWN PROMISES (cross-check, not the anchor). Every element the
       delta plan marks ADDED exists, every MODIFIED one carries its change, every REMOVED
-      one is gone and unreferenced. A promised element nobody built is a HIGH `plan` gap
+      one is gone and unreferenced; every endpoint the API delta adds or changes is served
+      at the route and verb its block gives, with its error contract, and every one it
+      removes is no longer served. A promised element nobody built is a HIGH `plan` gap
       even when the requirement it served looks satisfied elsewhere — the two usually mean
       the change was implemented in a different shape than was planned, which is worth
       knowing before the masters are re-derived from it. Where the code satisfies the
@@ -747,6 +815,131 @@ workflow:
       - { name: fe_ok,   from: "$.ok" }
       - { name: fe_gaps, from: "$.gaps" }
 
+  # ══════ PASS 3 — TEST CITATIONS. Is every requirement the change serves named by a test? ══════
+  # The deterministic half of check 2: the FR- and BR- ids each gated lane's delta plan rows
+  # serve, looked for in the slice's test files. An id the lane's check already reported as
+  # untested is not reported again (`--known-gaps`).
+  - id: cite_backend
+    condition: "{{be_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{delta_backend_plan}}", "--kind", "backend", "--mode", "delta", "--paths", "{{source_files}}", "--source-path", "{{be_source_path}}", "--test-path", "{{be_test_path}}", "--known-gaps", "{{be_gaps}}"]
+    outputs:
+      - { name: be_cite_ok,       from: "$.ok" }
+      - { name: be_cite_clean,    from: "$.clean" }
+      - { name: be_cite_warning,  from: "$.warning" }
+      - { name: be_uncited,       from: "$.uncited_text" }
+      - { name: be_cite_findings, from: "$.findings" }
+  - id: warn_cite_backend
+    condition: "{{be_gated}} == true"
+    action: verify_context
+    require_true: be_cite_clean
+    on_false: continue
+    on_false_message: "{{be_cite_warning}}"
+  - id: cite_frontend
+    condition: "{{fe_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-citations
+    args: ["--plan", "{{delta_frontend_plan}}", "--kind", "frontend", "--mode", "delta", "--paths", "{{source_files}}", "--source-path", "{{fe_source_path}}", "--test-path", "{{fe_test_path}}", "--known-gaps", "{{fe_gaps}}"]
+    outputs:
+      - { name: fe_cite_ok,       from: "$.ok" }
+      - { name: fe_cite_clean,    from: "$.clean" }
+      - { name: fe_cite_warning,  from: "$.warning" }
+      - { name: fe_uncited,       from: "$.uncited_text" }
+      - { name: fe_cite_findings, from: "$.findings" }
+  - id: warn_cite_frontend
+    condition: "{{fe_gated}} == true"
+    action: verify_context
+    require_true: fe_cite_clean
+    on_false: continue
+    on_false_message: "{{fe_cite_warning}}"
+
+  # ══════ PASS 4 — API. Does the built service serve the change's API as its delta API plan drafts it? ══════
+  # Only for a change that drafts an API change: contract-verify --cr --check reads the
+  # change's draft without the as-built document, so a behaviour-only change never runs the
+  # lane's export or its warnings. Only an explicit `needed: false` skips: a check that does
+  # not answer leaves the export armed.
+  - id: api_plan_check
+    condition: "{{be_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-verify
+    args: ["--feature-dir", "{{feature_dir}}", "--cr", "{{cr_id}}", "--check"]
+    outputs:
+      - { name: be_api_needed,    from: "$.needed" }
+      - { name: be_api_plan_note, from: "$.note" }
+  - id: api_nothing_to_check
+    condition: "{{be_api_plan_note}} != "
+    action: set
+    vars: { be_api_issues: "{{be_api_plan_note}}" }
+  - id: api_export
+    condition: "{{be_api_needed}} != false"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-export
+    outputs:
+      - { name: be_api_export_ok,     from: "$.ok" }
+      - { name: be_api_way,           from: "$.way" }
+      - { name: be_api_export_reason, from: "$.reason" }
+      - { name: be_api_export_log,    from: "$.log_tail" }
+      - { name: be_api_placeholder,   from: "$.placeholder" }
+  - id: api_no_way_flag
+    condition: "{{be_api_way}} == none"
+    action: set
+    vars: { be_api_has_way: "false" }
+  - id: warn_api_no_way
+    condition: "{{be_api_needed}} != false"
+    action: verify_context
+    require_true: be_api_has_way
+    on_false: continue
+    on_false_message: "API NOT CHECKED — {{be_api_export_reason}}. The frontend lane binds to the API this change's delta API plan drafts (changes/{{cr_id}}/api-draft.json); without the service's as-built document nothing checks that the code serves it. `contract_write` is any command that writes the service's OpenAPI document to the path {{be_api_placeholder}} stands for, with no server started."
+  - id: api_export_vote_set
+    condition: "{{be_api_needed}} != false"
+    action: set
+    vars: { be_api_export_vote: "{{be_api_export_ok}}" }
+  - id: api_export_failed
+    condition: "{{be_api_export_vote}} != true"
+    action: set
+    vars: { be_api_export_clean: "false" }
+  - id: api_export_no_way
+    condition: "{{be_api_has_way}} == false"
+    action: set
+    vars: { be_api_export_clean: "true" }
+  - id: warn_api_export
+    condition: "{{be_api_needed}} != false"
+    action: verify_context
+    require_true: be_api_export_clean
+    on_false: continue
+    on_false_message: "API NOT CHECKED — the service's as-built API document could not be written: {{be_api_export_reason}}. Correct `contract_write` (or `contract_run` / `contract`) on the service lane in .appweaver/stacks.json, start anything it needs, and re-run analyze-slice-delta {{cr_id}}. Output: {{be_api_export_log}}"
+  - id: api_verify
+    condition: "{{be_api_export_ok}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-verify
+    args: ["--feature-dir", "{{feature_dir}}", "--cr", "{{cr_id}}"]
+    outputs:
+      - { name: be_api_ok,       from: "$.ok" }
+      - { name: be_api_issues,   from: "$.issues_text" }
+      - { name: be_api_warning,  from: "$.warning" }
+      - { name: be_api_findings, from: "$.findings" }
+  - id: api_warning_flag
+    condition: "{{be_api_warning}} != "
+    action: set
+    vars: { be_api_clean: "false" }
+  - id: warn_api_fields
+    condition: "{{be_api_export_ok}} == true"
+    action: verify_context
+    require_true: be_api_clean
+    on_false: continue
+    on_false_message: "{{be_api_warning}}"
+
   # ═══════════════════════════ THE VERDICT ═══════════════════════════
   # requirements_ok = every GATED lane passed. Expressed as a raise-then-knock-down chain,
   # because the engine has no compound conditions and an ungated lane must not vote. A gated
@@ -768,6 +961,32 @@ workflow:
     condition: "{{fe_ok}} == true"
     action: set
     vars: { fe_req_vote: "true" }
+  # A requirement no test names knocks the lane's vote down, whatever its check said.
+  - id: be_cite_vote_set
+    condition: "{{be_gated}} == true"
+    action: set
+    vars: { be_cite_vote: "{{be_cite_ok}}" }
+  - id: be_req_vote_uncited
+    condition: "{{be_cite_vote}} != true"
+    action: set
+    vars: { be_req_vote: "false" }
+  # So does an endpoint the change drafts that the service does not serve as drafted.
+  - id: be_api_vote_set
+    condition: "{{be_api_export_ok}} == true"
+    action: set
+    vars: { be_api_vote: "{{be_api_ok}}" }
+  - id: be_req_vote_api
+    condition: "{{be_api_vote}} != true"
+    action: set
+    vars: { be_req_vote: "false" }
+  - id: fe_cite_vote_set
+    condition: "{{fe_gated}} == true"
+    action: set
+    vars: { fe_cite_vote: "{{fe_cite_ok}}" }
+  - id: fe_req_vote_uncited
+    condition: "{{fe_cite_vote}} != true"
+    action: set
+    vars: { fe_req_vote: "false" }
   - id: requirements_seed
     action: set
     vars: { requirements_ok: "true" }
@@ -791,7 +1010,7 @@ workflow:
     on_error: continue
     script: { ref: actions }
     subcommand: gap-route
-    args: ["--cr", "{{cr_id}}", "--gaps", "{{be_gaps}}", "--gaps", "{{fe_gaps}}"]
+    args: ["--cr", "{{cr_id}}", "--gaps", "{{be_gaps}}", "--gaps", "{{fe_gaps}}", "--gaps", "{{be_cite_findings}}", "--gaps", "{{fe_cite_findings}}", "--gaps", "{{be_api_findings}}"]
     outputs:
       - { name: gap_summary,   from: "$.summary" }
       - { name: gap_total,     from: "$.total" }
@@ -801,6 +1020,8 @@ workflow:
       - { name: fix_plan_n,    from: "$.plan_count" }
       - { name: fix_spec,      from: "$.specify_text" }
       - { name: fix_spec_n,    from: "$.specify_count" }
+      - { name: fix_tests,     from: "$.tests_text" }
+      - { name: fix_tests_n,   from: "$.tests_count" }
       - { name: fix_review,    from: "$.review_text" }
       - { name: fix_review_n,  from: "$.review_count" }
 
@@ -820,7 +1041,7 @@ workflow:
     on_error: continue
     script: { ref: actions }
     subcommand: slice-gate-stamp
-    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{be_test_ok}}", "--tests-ran", "{{be_test_ran}}", "--requirements-ok", "{{be_req_vote}}", "--findings", "{{be_gaps}}", "--lane", "backend"]
+    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{be_test_ok}}", "--tests-ran", "{{be_test_ran}}", "--requirements-ok", "{{be_req_vote}}", "--findings", "{{be_gaps}}", "--findings", "{{be_cite_findings}}", "--findings", "{{be_api_findings}}", "--lane", "backend"]
     outputs:
       - { name: be_verdict, from: "$.verdict" }
   - id: stamp_frontend
@@ -829,7 +1050,7 @@ workflow:
     on_error: continue
     script: { ref: actions }
     subcommand: slice-gate-stamp
-    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{fe_test_ok}}", "--tests-ran", "{{fe_test_ran}}", "--requirements-ok", "{{fe_req_vote}}", "--findings", "{{fe_gaps}}", "--lane", "frontend"]
+    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{fe_test_ok}}", "--tests-ran", "{{fe_test_ran}}", "--requirements-ok", "{{fe_req_vote}}", "--findings", "{{fe_gaps}}", "--findings", "{{fe_cite_findings}}", "--lane", "frontend"]
     outputs:
       - { name: fe_verdict, from: "$.verdict" }
 
@@ -850,7 +1071,7 @@ workflow:
   - id: be_state_gated
     condition: "{{be_gated}} == true"
     action: set
-    vars: { be_state: "gated — tests green={{be_test_ok}} (tool `{{be_test_tool}}`, actually ran={{be_test_ran}}), requirements met={{be_req_vote}}, recorded `{{be_verdict}}` in .aw-slice-gate.backend.json" }
+    vars: { be_state: "gated — tests green={{be_test_ok}} (tool `{{be_test_tool}}`, actually ran={{be_test_ran}}), requirements met={{be_req_vote}} (requirement ids no test names: {{be_uncited}}; the change's API as served: {{be_api_issues}}), recorded `{{be_verdict}}` in .aw-slice-gate.backend.json" }
   - id: fe_state_unnamed
     condition: "{{fe_declared}} == true"
     action: set
@@ -866,7 +1087,7 @@ workflow:
   - id: fe_state_gated
     condition: "{{fe_gated}} == true"
     action: set
-    vars: { fe_state: "gated — tests green={{fe_test_ok}} (tool `{{fe_test_tool}}`, actually ran={{fe_test_ran}}), requirements met={{fe_req_vote}}, recorded `{{fe_verdict}}` in .aw-slice-gate.frontend.json" }
+    vars: { fe_state: "gated — tests green={{fe_test_ok}} (tool `{{fe_test_tool}}`, actually ran={{fe_test_ran}}), requirements met={{fe_req_vote}} (requirement ids no test names: {{fe_uncited}}), recorded `{{fe_verdict}}` in .aw-slice-gate.frontend.json" }
 
   # THE REPORT IS ALWAYS WRITTEN — green or red. A green one is the record that this change
   # was verified built before it was merged, which is what makes the merge auditable; a red
@@ -903,10 +1124,14 @@ workflow:
       `{{working_lane}}`. Each gated lane ran its own tests and was checked on its own:
       - service lane: {{be_state}}. Matched a slice filter={{be_test_matched}},
         slice-scoped={{be_test_scoped}}. Failing lines: {{be_test_excerpt}} · Log tail:
-        {{be_test_log}} · gaps: {{be_gaps}}
+        {{be_test_log}} · gaps: {{be_gaps}} · test-citation findings (by script — an FR- or
+        BR- the delta plan serves that no test names): {{be_cite_findings}} · API findings
+        (by script — an endpoint the change adds or changes that the service does not serve
+        as its draft states, or one it removes that is still served): {{be_api_findings}}
       - experience lane: {{fe_state}}. Matched a slice filter={{fe_test_matched}},
         slice-scoped={{fe_test_scoped}}. Failing lines: {{fe_test_excerpt}} · Log tail:
-        {{fe_test_log}} · gaps: {{fe_gaps}}
+        {{fe_test_log}} · gaps: {{fe_gaps}} · test-citation findings (by script):
+        {{fe_cite_findings}}
       Markdown format:
       - "# Delta Slice Analyze Report — {{cr_id}}" plus today's date.
       - A verdict line: "verdict: REQUIREMENTS MET ✓" when every gated lane's tests are
@@ -921,7 +1146,7 @@ workflow:
         requirement findings below, not the fence, are what answer whether the change does
         what it was asked to.
       - "## Findings" as a table — | # | check | lane | severity | delta-spec ref | where |
-        finding | fixed by | — ordered high severity first, and within that the
+        finding | fixed by | — the gaps, the test-citation findings AND the API findings, ordered high severity first, and within that the
         `requirement` check first, because an unrealised requirement is the finding this
         gate exists for. Omit the section entirely when there are none, and say so under
         the verdict.
@@ -933,8 +1158,10 @@ workflow:
         /appweaver plan {{cr_id}}, then analyze-plan-delta. `specify` — the delta spec or
         the model delta is what is missing (a requirement realised in code that nothing
         asked for lands here too, as does a plan-only change that moved behaviour); re-run
-        /appweaver specify, which is the only phase that authors either. Then re-run
-        /appweaver analyze-slice-delta {{cr_id}}.
+        /appweaver specify, which is the only phase that authors either.
+        `fix-test-coverage` — a requirement no test names (the test-citation findings); run
+        /appweaver fix-test-coverage {{cr_id}}, which writes the tests and never code. Then
+        re-run /appweaver analyze-slice-delta {{cr_id}}.
       - Close with one line stating that this gate verifies only; it generated no code and
         repaired nothing.
       Return the complete report markdown only.
@@ -959,10 +1186,12 @@ workflow:
 
       CODE ({{fix_code_n}}): {{fix_code}}
 
+      TESTS ({{fix_tests_n}}): {{fix_tests}}
+
       UNROUTED ({{fix_review_n}}): {{fix_review}}
 
       Work them in that order — the spec before the plan that realises it, the plan before
-      the code that maps to it. Re-running /appweaver plan {{cr_id}} re-derives the delta
+      the code that maps to it, the code before its tests. Re-running /appweaver plan {{cr_id}} re-derives the delta
       plans with this report in context, so a plan finding is fixed by re-deriving rather
       than by hand-editing a generated document. The full report is at
       {{report_file}}. DO NOT run finalize-delta yet: merging now
@@ -999,6 +1228,7 @@ outputs:
   backend_ok: "{{be_ok}}"
   backend_gaps: "{{be_gaps}}"
   backend_verdict: "{{be_verdict}}"      # as recorded in .aw-slice-gate.backend.json
+  backend_untraced: "{{be_uncited}}"     # FR-/BR- ids the backend delta plan serves that no test names
   frontend_gated: "{{fe_gated}}"
   frontend_state: "{{fe_state}}"
   frontend_tests_green: "{{fe_test_ok}}"
@@ -1007,6 +1237,7 @@ outputs:
   frontend_ok: "{{fe_ok}}"
   frontend_gaps: "{{fe_gaps}}"
   frontend_verdict: "{{fe_verdict}}"     # as recorded in .aw-slice-gate.frontend.json
+  frontend_untraced: "{{fe_uncited}}"
   report: "{{report_file}}"                # delta-slice-analyze-report.<lane>.md when one lane of two is worked
   source_count: "{{source_count}}"
   note: "Gated change {{cr_id}} (wave {{wave}}) — delta-spec.md is the ANCHOR, so the question answered here is whether the CODE does what the change asked for, not whether it matches the plan. The delta plan is the MAP from a requirement to the element that serves it, and is cross-checked in its own right; the change's model delta supplies the invariants the code must enforce, and they are requirements too. The masters are read-only context for what was already there — they do not carry this change until finalize-delta merges it. Only a lane the change names, that you work on and that has a delta plan for THIS change is gated: backend — {{be_state}}; frontend — {{fe_state}}. An ungated lane is reported as not gated, never as a pass, and a lane somebody else works on is gated in their own run. Each gated lane ran its own tests, here for the first time on the change path since build only compiles, and its pass or fail is recorded in {{cr_dir}}/.aw-slice-gate.<lane>.json. This gate verifies: it generated no code and repaired nothing, and every finding names the command that closes it."