aw-spec-cli 0.1.20 → 0.1.22

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

@@ -30,7 +30,8 @@
 # and that is the act a change in flight forbids — the delta docs are the authoritative
 # edit and the masters must not drift out from under them before finalize-delta merges.
 #   MASTER mode  (no change open) — the full gate: check, ask, repair, and STOP on gaps
-#                that could not be reconciled. spec.md + the lane plans are the masters.
+#                a plan rewrite could have closed but did not. spec.md + the lane plans
+#                are the masters.
 #   REPORT mode  (a change is open) — the same checks, read-only: no ask, no repair, no
 #                stop. It writes plan-analyze-report.md and routes on. The plans are
 #                DERIVED from spec.md + domain-model.md, so after finalize-delta merged a
@@ -40,6 +41,18 @@
 # to be stale, and a stage that refuses to look is not a gate. It reports; it never writes
 # a plan.
 #
+# TWO KINDS OF GAP, SPLIT BY WHO CAN CLOSE THEM (plan-gaps). A PLAN gap is closed by
+# rewriting a lane plan, which this stage may do. A ROUTED gap can only be closed in
+# spec.md or domain-model.md, which this stage may not write: a LIFT-FAILURE (a domain
+# constraint the spec never lifted), structure the model does not define, behaviour the
+# spec does not describe. Only plan gaps drive the repair loop and the stop; routed gaps
+# are reported and handed to /appweaver specify. Stopping on them would stop every feature
+# whose spec missed a constraint, with no repair this stage could ever make.
+#
+# EVERY MASTER RUN LEAVES A RECEIPT (.aw-plan-gate.json), green or not: the bytes it
+# checked and the verdict — conformant, routed-gaps or gaps. implement reads it and
+# refuses moved bytes or `gaps`, and warns on `routed-gaps`.
+#
 # WHICH MODE IS READ FROM THE DIRECTORY, AND DEFAULTS TO REPORT. changes/<id>/ is the
 # evidence (cr-list), not active_version.json's `active_change` — the ledger is the most
 # recently OPENED change and a crashed run can leave the two disagreeing. The permission to
@@ -60,7 +73,7 @@
 
 name: aw-spec-analyze-plan
 description: The spec↔plan conformance gate for every declared lane — confirm backend-plan.md and frontend-plan.md follow spec.md, that they bind to each other's contract, and that neither contradicts the bounded context's domain model (domain overlays are a backstop); with approval, repair the drifting plan. Lanes come from .appweaver/stacks.json, so one command gates backend-only, frontend-only and full-stack projects. Runs in one of two modes, decided from the changes/ directory rather than the ledger and defaulting to the read-only one — MASTER (no change open) checks, repairs on approval and stops on unreconciled gaps; REPORT (a change open) runs the same checks read-only and writes plan-analyze-report.md without asking, repairing or stopping, because the master plans may not be rewritten while a delta is in flight. It never opens, merges or closes a change.
-version: 3.2.0
+version: 3.3.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -68,6 +81,9 @@ 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
 
 standards:
   - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
@@ -87,8 +103,16 @@ vars:
   no_open_change: "false"  # RAISED only by cr-list answering that nothing is open
   gate_mode: "report"      # report | master — reported in the outputs
   may_repair: "false"      # the ask, the repair loop and the conformance stop are MASTER-only
-  gate_ok: "false"         # raised by a conformant run OR by report mode, which cannot repair
-  stamp_receipt: "false"   # master mode AND conformant ⇒ leave the receipt implement reads
+  gate_ok: "false"         # raised by a run with no plan gap left OR by report mode, which cannot repair
+  stamp_receipt: "false"   # master mode ⇒ leave the receipt implement reads, whatever the verdict
+  repairs_left: "true"     # lowered on the loop's final pass, which checks and never rewrites
+  # THE GAP SPLIT, from plan-gaps after each analyze pass. Defaulted to the refusing
+  # answer, so a classification that never arrived neither ends the loop nor passes.
+  plan_ok: "false"         # no gap left that a plan rewrite closes
+  gate_verdict: "gaps"     # conformant | routed-gaps | gaps
+  plan_gap_count: "0"
+  routed_gaps: "[]"        # the gaps only /appweaver specify can close
+  routed_csv: ""
   receipt_file: ""
   receipt_gated: ""
   receipt_count: "0"
@@ -358,19 +382,30 @@ workflow:
       - { path: "{{be_plan_ctx}}", optional: true }
       - { path: "{{fe_plan_ctx}}", optional: true }
 
-  # 5. Conformance + REPAIR loop (spec is the anchor): check → REPORT gaps + ASK →
-  #    Repair on approval → re-check; "Report and Skip" writes plan-analyze-report.md
-  #    and stops. Bounded (3×). The repair is PER LANE, so a frontend drift never
-  #    rewrites a conformant backend plan.
+  # 5. Conformance + REPAIR loop (spec is the anchor): check → split the gaps → REPORT +
+  #    ASK → Repair on approval → re-check; "Report and Skip" writes plan-analyze-report.md
+  #    and stops. The loop runs while a PLAN gap is open: once only routed gaps remain
+  #    there is nothing a repair can change. The repair is PER LANE, so a frontend drift
+  #    never rewrites a conformant backend plan.
+  #
+  #    THREE REPAIRS, FOUR PASSES — the last pass checks and never rewrites. With the two
+  #    equal, the third repair was the last thing to run: no pass ever saw its result, so a
+  #    run that converged on it still reported `gaps` and told the operator it had not
+  #    converged. Worse, plan_ok / gate_verdict / plan_gap_count then described the plans as
+  #    they were BEFORE that repair, while plan-gate-stamp below hashed the files as they
+  #    are AFTER it — a receipt pairing post-repair bytes with a pre-repair verdict, which
+  #    plan-gate-check would later read as fresh. The extra pass costs one analyze in the
+  #    case that used to end ambiguously, and it makes the last thing to touch the plans
+  #    always earlier than the last thing to judge them, on every exit path.
   - id: analyze_loop
     action: loop
-    while: "{{analyze_ok}} != true"
-    max_iterations: 3
+    while: "{{plan_ok}} != true"
+    max_iterations: 4
     steps:
       - id: analyze
         action: agent_query
         include_standards: true            # the gate overlays (checklist) are in the standards
-        schema: { ok: true, backend_repair: false, frontend_repair: false, gaps: [ { severity: "high", check: "<spec-backend|spec-frontend|contract|model|overlay>", lane: "<backend|frontend>", spec_ref: "<FR/BR/CN/DC/IC/UX/US/SC or overlay or —>", where: "<plan section>", gap: "<how it drifts>" } ] }
+        schema: { ok: true, backend_repair: false, frontend_repair: false, gaps: [ { severity: "high", check: "<spec-backend|spec-frontend|contract|model|overlay>", lane: "<backend|frontend>", route: "<plan|specify>", spec_ref: "<FR/BR/CN/DC/IC/UX/US/SC or overlay or —>", where: "<plan section>", gap: "<how it drifts>" } ] }
         mock: { ok: true, backend_repair: false, frontend_repair: false, gaps: [] }
         task: |
           spec.md is the ANCHOR. Gate this feature's LANE PLANS against it and against the
@@ -444,15 +479,37 @@ workflow:
           /appweaver specify, not the plan — do not fabricate it here).
 
           Tag every gap with its `check` and the `lane` whose document must change to close
-          it. Set backend_repair true if any gap needs the backend plan rewritten, and
-          frontend_repair likewise. (If a plan is still the empty template, treat the WHOLE
-          spec as gaps against it.) Set ok=true ONLY when every applicable check passes and
-          no checklist constraint is unaccounted for.
+          it, and with its `route` — who can close it:
+          - route `specify` when ONLY spec.md or domain-model.md can close it: every
+            LIFT-FAILURE; a plan element needing an aggregate, entity, event or invariant
+            the model does not define; a state or behaviour the plan needs that the spec
+            does not describe and no DA-n records.
+          - route `plan` for everything a rewrite of a lane plan closes: a missing plan
+            home, a name that differs from the model's, an invariant restated instead of
+            cited, a contract binding, an element with no spec basis.
+          Set backend_repair true if any `plan`-route gap needs the backend plan rewritten,
+          and frontend_repair likewise. (If a plan is still the empty template, treat the
+          WHOLE spec as gaps against it.) Set ok=true ONLY when every applicable check
+          passes and no checklist constraint is unaccounted for.
         outputs:
           - { name: analyze_ok,      from: "$.ok" }
           - { name: analyze_gaps,    from: "$.gaps" }
           - { name: backend_repair,  from: "$.backend_repair" }
           - { name: frontend_repair, from: "$.frontend_repair" }
+
+      # WHO CAN CLOSE EACH GAP, decided by script from the tags above: a LIFT-FAILURE is
+      # routed to specify whatever its tag says, and an untagged gap is a plan gap.
+      - id: classify_gaps
+        action: execute_script
+        script: { ref: actions }
+        subcommand: plan-gaps
+        args: ["--gaps", "{{analyze_gaps}}"]
+        outputs:
+          - { name: plan_ok,        from: "$.plan_ok" }
+          - { name: gate_verdict,   from: "$.verdict" }
+          - { name: plan_gap_count, from: "$.plan_gaps" }
+          - { name: routed_gaps,    from: "$.routed" }
+          - { name: routed_csv,     from: "$.routed_csv" }
       - id: conform_break
         action: break
         condition: "{{analyze_ok}} == true"
@@ -495,12 +552,32 @@ workflow:
         action: break
         condition: "{{may_repair}} == false"
 
+      # Only routed gaps left: no repair can change them, so do not ask for one.
+      - id: routed_only_break
+        action: break
+        condition: "{{plan_ok}} == true"
+
+      # THE LAST PASS CONFIRMS THE LAST REPAIR AND DOES NOT ADD ONE. Raised for every pass
+      # and lowered on the final one, so the ask below and both lane rewrites are skipped
+      # there while the analyze above still runs and still sets the verdict.
+      - id: repairs_left_yes
+        action: set
+        vars: { repairs_left: "true" }
+      - id: repairs_left_no
+        condition: "{{iteration}} == 3"
+        action: set
+        vars: { repairs_left: "false" }
+
       - id: ask_repair
+        condition: "{{repairs_left}} == true"
         action: ask
         prompt: |
           analyze-plan found spec↔plan gaps (spec.md is the anchor; domain-model.md is
           read-only here):
           {{analyze_gaps}}
+          {{plan_gap_count}} gap(s) have route `plan` — a repair rewrites the plan to close
+          them. Gaps with route `specify` are not repaired here; they are reported and
+          belong to /appweaver specify.
           Repair the drifting plan(s) to conform now, or report the gaps and stop?
         options: ["Repair", "Report and Skip"]
         answer_var: repair_choice
@@ -528,9 +605,11 @@ workflow:
         condition: "{{repair_choice}} == Report and Skip"
 
       # WHICH DOCUMENT GETS REWRITTEN. A repair runs only where the analyze pass reported
-      # drift in that lane AND that lane is present — two ordered assignments per lane,
-      # cleared first so a lane that was repaired on the previous iteration and is clean
-      # on this one is not rewritten again.
+      # drift in that lane AND that lane is present AND this pass still carries a repair —
+      # three ordered assignments per lane, because the dialect takes no compound
+      # condition. Cleared first so a lane that was repaired on the previous iteration and
+      # is clean on this one is not rewritten again, and cleared last on the final pass,
+      # which exists to check the previous repair rather than to add another.
       - id: be_repair_clear
         action: set
         vars: { be_repair: "false" }
@@ -538,6 +617,10 @@ workflow:
         condition: "{{backend_repair}} == true"
         action: set
         vars: { be_repair: "{{be_present}}" }
+      - id: be_repair_last_pass
+        condition: "{{repairs_left}} == false"
+        action: set
+        vars: { be_repair: "false" }
       - id: fe_repair_clear
         action: set
         vars: { fe_repair: "false" }
@@ -545,6 +628,10 @@ workflow:
         condition: "{{frontend_repair}} == true"
         action: set
         vars: { fe_repair: "{{fe_present}}" }
+      - id: fe_repair_last_pass
+        condition: "{{repairs_left}} == false"
+        action: set
+        vars: { fe_repair: "false" }
 
       - id: repair_backend
         condition: "{{be_repair}} == true"
@@ -553,7 +640,8 @@ workflow:
         output_target: { type: file, path: "{{backend_plan}}" }
         task: |
           spec.md is the ANCHOR — update backend-plan.md (in context) to CONFORM to it,
-          closing the gaps whose lane is `backend` (the spec WINS every time):
+          closing the gaps whose lane is `backend` and whose route is `plan` (the spec WINS
+          every time). Leave `specify`-route gaps as the DA-n notes described below:
           {{analyze_gaps}}
           - Add a plan home for each uncovered spec FR/BR/CN/DC/IC/US/SC (a lifted
             CN-/DC-/IC- lands in a §1 domain invariant enforcement · the persistence
@@ -591,7 +679,9 @@ workflow:
         output_target: { type: file, path: "{{frontend_plan}}" }
         task: |
           spec.md is the ANCHOR — update frontend-plan.md (in context) to CONFORM to it,
-          closing the gaps whose lane is `frontend` (the spec WINS every time):
+          closing the gaps whose lane is `frontend` and whose route is `plan` (the spec WINS
+          every time). Leave each `specify`-route gap open, logged as a DA-n that routes to
+          /appweaver specify:
           {{analyze_gaps}}
           - Give every uncovered Experience Standard (UX-), user story and
             interaction-state FR- a home: a screen in the navigation section, a flow row,
@@ -618,52 +708,51 @@ workflow:
             already-conformant section VERBATIM.
           Return the COMPLETE updated frontend-plan.md content only.
 
-  # THE STOP IS MASTER MODE'S ALONE. Two independent raises, because the two reasons to
-  # pass are unrelated: the plans conform, or this run was never allowed to change them.
-  # A read-only run that found gaps has done its whole job by reporting them — stopping
-  # would fail the operator for drift that finalize-delta created on purpose and that only
-  # /appweaver plan main can close.
-  - id: gate_ok_conformant
-    condition: "{{analyze_ok}} == true"
-    action: set
-    vars: { gate_ok: "true" }
-  - id: gate_ok_readonly
-    condition: "{{may_repair}} == false"
-    action: set
-    vars: { gate_ok: "true" }
-
-  - id: analyze_gate
-    action: verify_context
-    require_true: gate_ok
-    on_false: stop
-    on_false_message: "The lane plans do not conform to the spec (gaps: {{analyze_gaps}}) — repair was skipped (see plan-analyze-report.md), or it could not be reconciled in 3 passes. A 'LIFT-FAILURE:' gap means a domain constraint from the gate checklist was never lifted into the spec, and a `model` gap means the plan needs an entity or invariant domain-model.md does not define — both are fixed by /appweaver specify, which authors the spec and the model; this gate may not write either. A `contract` gap is closed in the lane its row names. Otherwise fix out of band, or re-run and choose Repair."
-
   # THE RECEIPT. implement generates from the plans and deliberately does not read the
-  # spec, on the strength of this stage having conformed them to it — which until now was
-  # an assumption about the order the operator ran things in, checked by nothing. Record
-  # WHAT was proven: the bytes of spec.md, the context's domain-model.md and each lane plan
-  # that was present. plan-gate-check reads it at implement.
+  # spec, on the strength of this stage having checked them against it. Record WHAT was
+  # checked — the bytes of spec.md, the context's domain-model.md and each lane plan that
+  # was present — and the VERDICT on them. plan-gate-check reads it at implement.
   #
-  # ONLY A GREEN MASTER RUN LEAVES ONE. The AND is the kit's ordered assignment — under
-  # master mode, take the conformance verdict as the answer — because the engine has no
-  # compound conditions. A REPORT-mode run proves nothing about the masters (it may not
-  # even repair them), and a red master run proved the opposite.
+  # EVERY MASTER RUN LEAVES ONE, and it is written BEFORE the stop below, so a red run
+  # records its `gaps` verdict too and implement refuses it. A REPORT-mode run leaves
+  # none: it checked the masters while a delta was in flight, and they are about to move.
   - id: flag_receipt
     condition: "{{may_repair}} == true"
     action: set
-    vars: { stamp_receipt: "{{analyze_ok}}" }
+    vars: { stamp_receipt: "true" }
 
   - id: plan_gate_stamp
     condition: "{{stamp_receipt}} == true"
     action: execute_script
     script: { ref: actions }
     subcommand: plan-gate-stamp
-    args: ["--feature-dir", "{{feature_dir}}", "--spec-version", "{{version}}", "--mode", "{{gate_mode}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--spec-version", "{{version}}", "--mode", "{{gate_mode}}", "--verdict", "{{gate_verdict}}", "--plan-gaps", "{{plan_gap_count}}", "--routed", "{{routed_gaps}}"]
     outputs:
       - { name: receipt_file,  from: "$.file" }
       - { name: receipt_gated, from: "$.gated" }
       - { name: receipt_count, from: "$.count" }
 
+  # THE STOP IS MASTER MODE'S ALONE, and only a PLAN gap triggers it. Two independent
+  # raises, because the two reasons to pass are unrelated: no gap is left that a plan
+  # rewrite closes, or this run was never allowed to rewrite. A read-only run that found
+  # gaps has done its whole job by reporting them — stopping would fail the operator for
+  # drift that finalize-delta created on purpose and that only /appweaver plan main can
+  # close. Routed gaps pass here and are listed in the outputs for /appweaver specify.
+  - id: gate_ok_conformant
+    condition: "{{plan_ok}} == true"
+    action: set
+    vars: { gate_ok: "true" }
+  - id: gate_ok_readonly
+    condition: "{{may_repair}} == false"
+    action: set
+    vars: { gate_ok: "true" }
+
+  - id: analyze_gate
+    action: verify_context
+    require_true: gate_ok
+    on_false: stop
+    on_false_message: "The lane plans do not conform to the spec: {{plan_gap_count}} gap(s) a plan rewrite closes are still open (all gaps: {{analyze_gaps}}). Either you chose `Report and Skip`, in which case plan-analyze-report.md beside the plans lists them — or repair ran up to three times and the fourth pass, which checks and does not rewrite, still found these. Every gap above was read off the plans as they stand on disk now. The receipt records verdict `gaps`, so /appweaver implement will refuse until this gate is re-run clean. A `contract` gap is closed in the lane its row names. Gaps routed to `specify` ({{routed_csv}}) are not what stopped this run: they need /appweaver specify, which authors the spec and the model. Fix out of band, or re-run and choose Repair."
+
   # (No change-close here by design — this stage never archives anything in either mode,
   #  and cr-archive belongs to close-delta, which runs after finalize-delta's merge.)
 
@@ -687,10 +776,13 @@ outputs:
   domain_model: "{{domain_model}}"
   conformant: "{{analyze_ok}}"
   gaps: "{{analyze_gaps}}"
+  verdict: "{{gate_verdict}}"       # conformant | routed-gaps | gaps
+  plan_gaps: "{{plan_gap_count}}"   # open gaps a plan rewrite closes
+  routed_to_specify: "{{routed_csv}}"   # open gaps only /appweaver specify can close
   version: "{{version}}"
   gate_mode: "{{gate_mode}}"        # master (repair allowed) | report (read-only)
   open_changes: "{{open_ids}}"      # empty in master mode, by definition
-  gate_receipt: "{{receipt_file}}"  # written only by a GREEN master run; implement reads it
+  gate_receipt: "{{receipt_file}}"  # written by every master run, with its verdict; implement reads it
   gate_receipt_at: "{{receipt_gated}}"
   note: "Ran in {{gate_mode}} mode ({{open_count}} change(s) open: {{open_ids}}). Checked: spec→backend-plan ({{be_present}}), spec→frontend-plan ({{fe_present}}), the plan↔plan contract binding ({{both_lanes}} — it needs both lanes) and both plans against domain-model.md. The domain model was READ, never written: a gap that needs a new entity, event or invariant is fixed by /appweaver specify. In REPORT mode no plan was rewritten either — the master plans are derived documents and may not move while a delta is in flight."
-  next: "MASTER mode (no change open, conformant={{analyze_ok}}): /appweaver implement — the plans conform to the spec; version unchanged, this gate closes nothing. REPORT mode (change(s) {{open_ids}} open): this run was read-only and wrote plan-analyze-report.md only. If finalize-delta has already merged, the gaps ARE that merge — the lane plans are derived from spec.md + domain-model.md and finalize-delta moves only those two, so re-derive with /appweaver plan main after /appweaver close-delta, then re-run /appweaver analyze-plan in master mode. If the change has NOT merged yet, gate it where it lives: /appweaver analyze-plan-delta."
+  next: "MASTER mode (no change open, verdict={{gate_verdict}}): /appweaver implement — no gap a plan rewrite closes is left; version unchanged, this gate closes nothing. If the verdict is routed-gaps, implement generates and warns: {{routed_csv}} — each is a spec or model gap, lifted by opening a change with /appweaver specify. REPORT mode (change(s) {{open_ids}} open): this run was read-only and wrote plan-analyze-report.md only. If finalize-delta has already merged, the gaps ARE that merge — the lane plans are derived from spec.md + domain-model.md and finalize-delta moves only those two, so re-derive with /appweaver plan main after /appweaver close-delta, then re-run /appweaver analyze-plan in master mode. If the change has NOT merged yet, gate it where it lives: /appweaver analyze-plan-delta."

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

@@ -70,7 +70,7 @@
 # =============================================================================
 
 name: aw-spec-analyze-slice-delta
-version: 1.0.0
+version: 1.2.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, runs the slice's tests (the first execution on the change path, since build only compiles), then evaluates the code and its paired tests 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. 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,11 +124,24 @@ vars:
   test_ok: "false"
   test_tool: ""
   test_log: ""
+  test_excerpt: ""
   test_scoped: "false"
   test_ran: "false"
   test_matched: "false"
   # Verdict.
   requirements_ok: "false"
+  # 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"
+  gap_total: "0"
+  fix_code: "none"
+  fix_code_n: "0"
+  fix_plan: "none"
+  fix_plan_n: "0"
+  fix_spec: "none"
+  fix_spec_n: "0"
+  fix_review: "none"
+  fix_review_n: "0"
   gate_ok: "false"
 
 workflow:
@@ -155,9 +168,11 @@ workflow:
       - { name: be_declared,    from: "$.backend_declared" }
       - { name: be_lane_id,     from: "$.backend_lane_id" }
       - { name: be_source_path, from: "$.backend_source_path" }
+      - { name: be_test_path,   from: "$.backend_test_path" }
       - { name: fe_declared,    from: "$.frontend_declared" }
       - { name: fe_lane_id,     from: "$.frontend_lane_id" }
       - { name: fe_source_path, from: "$.frontend_source_path" }
+      - { name: fe_test_path,   from: "$.frontend_test_path" }
 
   - id: require_lane
     action: verify_context
@@ -316,6 +331,7 @@ workflow:
       - { name: test_ok,      from: "$.fence_green" }
       - { name: test_tool,    from: "$.tool" }
       - { name: test_log,     from: "$.log_tail" }
+      - { name: test_excerpt, from: "$.failing_excerpt" }   # the lines that NAME the failure
       - { name: test_scoped,  from: "$.scoped" }
       # A GREEN FENCE IS NOT ALWAYS AN EXECUTED SUITE. test-run reports fence_green true
       # with ran=false on a project whose lanes declare no test command — the vacuous pass
@@ -414,9 +430,11 @@ workflow:
       the pre-existing slice.
 
       CHECK 7 — PLACEMENT. Every file this change added or edited sits under the lane that
-      owns it: this lane's source path is `{{be_source_path}}`. A service-lane element
-      written into the frontend lane's subtree — or outside every lane root — is a HIGH
-      `placement` gap.
+      owns it: this lane's production code under its source path `{{be_source_path}}`, its
+      tests under its test path `{{be_test_path}}`. A service-lane element written into the
+      frontend lane's subtree — or outside every lane's paths — is a HIGH `placement` gap.
+      One edit outside them is allowed: registering a test project this change created in
+      the file the lane's test command discovers tests through (e.g. a .NET solution file).
 
       PLAN-ONLY CHANGE — if the delta-spec is an unfilled stub, this change deliberately
       alters only HOW the EXISTING spec is realised (a refactor, an architectural decision).
@@ -506,9 +524,11 @@ workflow:
       gap. Judge it only over what this change touched.
 
       CHECK 7 — PLACEMENT. Every file this change added or edited sits under this lane's
-      source path, `{{fe_source_path}}`. A file written into the service lane's subtree is a
-      HIGH `placement` gap — a gap in the service surface is a contract delta raised back to
-      that lane, never a client-side edit to it.
+      source path, `{{fe_source_path}}`, or — for a test — its test path, `{{fe_test_path}}`.
+      A file written into the service lane's subtree is a HIGH `placement` gap — a gap in the
+      service surface is a contract delta raised back to that lane, never a client-side edit
+      to it. The one edit allowed outside them is the test setup this change had to create,
+      when the lane's test command discovers tests through a file elsewhere.
 
       PLAN-ONLY CHANGE — if the delta-spec is an unfilled stub, this change alters only HOW
       the existing spec is realised. Checks 1 to 3 have no anchor and are SKIPPED, not
@@ -539,6 +559,30 @@ workflow:
     action: set
     vars: { requirements_ok: "false" }
 
+  # WHO CAN CLOSE WHAT. Both lanes' findings carry a `fix` tag already; this turns the tag
+  # into routing. It matters most for a `plan` finding: the delta plan is what is wrong, and
+  # `implement` generates FROM that plan, so sending it there reproduces the defect — which
+  # is what left the mock run's ChiefComplaintField gap closable only by hand-editing a
+  # generated plan. Deterministic, and it never drops a finding: one with no recognised
+  # `fix` is routed to `review` and counted, rather than folded into the largest bucket.
+  - id: route_gaps
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: gap-route
+    args: ["--cr", "{{cr_id}}", "--gaps", "{{be_gaps}}", "--gaps", "{{fe_gaps}}"]
+    outputs:
+      - { name: gap_summary,   from: "$.summary" }
+      - { name: gap_total,     from: "$.total" }
+      - { name: fix_code,      from: "$.implement_text" }
+      - { name: fix_code_n,    from: "$.implement_count" }
+      - { name: fix_plan,      from: "$.plan_text" }
+      - { name: fix_plan_n,    from: "$.plan_count" }
+      - { name: fix_spec,      from: "$.specify_text" }
+      - { name: fix_spec_n,    from: "$.specify_count" }
+      - { name: fix_review,    from: "$.review_text" }
+      - { name: fix_review_n,  from: "$.review_count" }
+
   # gate_ok = the tests ran green AND every gated lane's requirements are met.
   - id: gate_flag
     condition: "{{test_ok}} == true"
@@ -568,8 +612,8 @@ workflow:
       merges the change into spec.md and domain-model.md.
       Evidence:
       - tests: green={{test_ok}}, tool `{{test_tool}}`, actually ran={{test_ran}},
-        matched a slice filter={{test_matched}}, slice-scoped={{test_scoped}}. Log tail:
-        {{test_log}}
+        matched a slice filter={{test_matched}}, slice-scoped={{test_scoped}}. Failing
+        lines: {{test_excerpt}} · Log tail: {{test_log}}
       - service lane gated={{be_gated}}, verdict ok={{be_ok}}, gaps: {{be_gaps}}
       - experience lane gated={{fe_gated}}, verdict ok={{fe_ok}}, gaps: {{fe_gaps}}
       Markdown format:
@@ -608,7 +652,31 @@ workflow:
     action: verify_context
     require_true: gate_ok
     on_false: stop
-    on_false_message: "Change {{cr_id}} does NOT yet meet its delta spec. Tests green={{test_ok}} (tool `{{test_tool}}`); service lane gated={{be_gated}} ok={{be_ok}}; experience lane gated={{fe_gated}} ok={{fe_ok}}. Findings — backend: {{be_gaps}} · frontend: {{fe_gaps}}. The full report, with the command that closes each finding, is at {{cr_dir}}/delta-slice-analyze-report.md. DO NOT run finalize-delta yet: merging now would write requirements into spec.md and domain-model.md that the code does not satisfy, and the masters would describe an intention rather than the system. Fix the findings (a `requirement` or `plan` finding is usually /appweaver implement {{cr_id}}), re-run build, then re-run this gate."
+    on_false_message: >
+      Change {{cr_id}} does NOT yet meet its delta spec. Tests green={{test_ok}} (tool
+      `{{test_tool}}`); service lane gated={{be_gated}} ok={{be_ok}}; experience lane
+      gated={{fe_gated}} ok={{fe_ok}}. {{gap_summary}}
+
+      EACH FINDING IS CLOSED BY A DIFFERENT COMMAND — they are not interchangeable, and a
+      plan defect sent to implement comes back unchanged, because implement generates FROM
+      the plan.
+
+      SPEC / MODEL ({{fix_spec_n}}): {{fix_spec}}
+
+      DELTA PLAN ({{fix_plan_n}}): {{fix_plan}}
+
+      CODE ({{fix_code_n}}): {{fix_code}}
+
+      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
+      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
+      {{cr_dir}}/delta-slice-analyze-report.md. DO NOT run finalize-delta yet: merging now
+      would write requirements into spec.md and domain-model.md that the code does not
+      satisfy, and the masters would describe an intention rather than the system. Then
+      re-run build and re-run this gate.
 
   # 6. Post-execution hooks.
   - id: resolve_post_hooks