aw-spec-cli 0.1.19 → 0.1.21

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

@@ -36,8 +36,8 @@
 # is visible so it can be designed around, and building on it silently is the defect this
 # check exists to catch.
 #
-# OVERLAP IS COMPUTED, NOT ASKED. cr-overlap reads the `## Aggregate:` headings of every
-# pending model delta and reports which other open changes touch the same aggregates.
+# OVERLAP IS COMPUTED, NOT ASKED. cr-overlap reads the `**Aggregates touched**:` header of
+# every pending model delta and reports which other open changes touch the same aggregates.
 # That is a fact about two files, so a regex answers it exactly and the result is handed
 # to the model as a finding rather than as a question.
 #
@@ -153,7 +153,7 @@ workflow:
     action: verify_context
     require_non_empty: feature_dir
     on_empty: stop
-    on_empty_message: "No active feature. Run /appweaver select-feature first (pick or create the aggregate, e.g. Order), then re-run analyze-plan-delta."
+    on_empty_message: "No active feature. Run /appweaver select-feature first (pick or create the feature, e.g. Order or PatientRegistration), then re-run analyze-plan-delta."
 
   - id: verify_spec
     action: verify_context
@@ -229,9 +229,9 @@ workflow:
       - { name: sibling_count,             from: "$.sibling_count" }
       - { name: domain_model,              from: "$.domain_model" }
 
-  # 3b. WHICH OTHER OPEN CHANGES TOUCH THE SAME AGGREGATES. Deterministic: the
-  #     `## Aggregate:` headings of the pending model deltas are the merge unit
-  #     domain-model.md is organised by, so this is a regex over two files rather than a
+  # 3b. WHICH OTHER OPEN CHANGES TOUCH THE SAME AGGREGATES. Deterministic: each pending
+  #     model delta's `**Aggregates touched**:` header names the `## Aggregate:` sections
+  #     of domain-model.md it merges into, so this is a regex over two files rather than a
   #     judgement. The result reaches the check below as a FINDING, not a question.
   - id: cr_overlap
     action: execute_script
@@ -645,7 +645,7 @@ workflow:
     action: verify_context
     require_true: analyze_ok
     on_false: stop
-    on_false_message: "The delta plans for {{cr_id}} do not realise the delta spec (gaps: {{analyze_gaps}}) — repair was skipped (see {{cr_dir}}/delta-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 delta spec, and a `model` gap means a plan needs structure the effective model does not define — both are fixed by /appweaver specify, which authors the delta spec and the model delta; this gate may not write either. A `wave` gap is closed by declaring '## Depends on' (and raising the wave with cr-wave) or by planning around the sibling. Otherwise fix out of band, or re-run and choose Repair."
+    on_false_message: "The delta plans for {{cr_id}} do not realise the delta spec (gaps: {{analyze_gaps}}) — repair was skipped (see {{cr_dir}}/delta-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 delta spec, and a `model` gap means a plan needs structure the effective model does not define — both are fixed by /appweaver specify, which authors the delta spec and the model delta; this gate may not write either. A `wave` gap is closed by declaring '## Depends on' — which is what sets the wave, since specify derives it from that section and the merge fence re-checks it — or by planning around the sibling. Otherwise fix out of band, or re-run and choose Repair."
 
   # 8. Post-execution hooks.
   - id: resolve_post_hooks

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,15 @@ 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
+  # 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"
@@ -122,6 +145,10 @@ vars:
   be_plan_ctx: ""
   fe_plan_ctx: ""
   domain_model: ""
+  owned_sections: ""           # the model section(s) this feature answers for — feature-aggregates
+  shared_with_csv: ""
+  one_to_one: "true"
+  model_scope_plan: ""         # which part of those sections check 4(a) holds the plan to
 
 workflow:
 
@@ -175,11 +202,40 @@ workflow:
       - { name: domain_model,        from: "$.domain_model" }
       - { name: domain_model_exists, from: "$.domain_model_exists" }
 
+  # WHICH PART OF THAT MODEL CHECK 4 HOLDS THE PLAN TO. A feature is a capability scope the
+  # developer chose — it may act on several aggregates, and several features may act on
+  # one — so "the plan matches its aggregate's section" is only exact for a feature that
+  # alone answers for that aggregate. Resolved from the spec's Acts-on line, then the
+  # boundary map, then the feature name.
+  - id: feature_aggregates
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: feature-aggregates
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: owned_sections,  from: "$.owned_sections" }
+      - { name: shared_with_csv, from: "$.shared_with_csv" }
+      - { name: one_to_one,      from: "$.one_to_one" }
+
+  # A shared section is realised by several plans, each covering what its own feature
+  # acts on; flagging every element one plan leaves out would fail each of them for work
+  # another feature's plan carries. Ordered pair of sets — no conditional prompt text.
+  - id: model_scope_shared
+    action: set
+    vars:
+      model_scope_plan: "{{owned_sections}}, which this feature SHARES with other features: every element the plan realises must carry the model's name and sit inside the model's boundary, but an element of the section the plan leaves out is NOT a gap unless this feature's requirements act on it — another feature's plan realises it"
+  - id: model_scope_sole
+    condition: "{{one_to_one}} == true"
+    action: set
+    vars:
+      model_scope_plan: "{{owned_sections}}. This feature is the only one that answers for it, so the plan's domain layer must realise that whole section"
+
   - 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 (pick or create the aggregate, e.g. Order), then re-run analyze-plan."
+    on_empty_message: "No active feature. Run /appweaver select-feature first (pick or create the feature, e.g. Order or PatientRegistration), then re-run analyze-plan."
 
   - id: verify_spec
     action: verify_context
@@ -325,19 +381,20 @@ 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. Bounded (3×). 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.
   - id: analyze_loop
     action: loop
-    while: "{{analyze_ok}} != true"
+    while: "{{plan_ok}} != true"
     max_iterations: 3
     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
@@ -388,9 +445,10 @@ workflow:
 
           CHECK 4 — the plans → domain-model.md (when the model is in context; skip if it
           is not):
-          (a) the backend plan's DOMAIN layer matches the model EXACTLY — entities and
-          value objects are its aggregate section's entities (SAME names), the boundary is
-          its Boundary block, states are the lifecycle it describes;
+          (a) the backend plan's DOMAIN layer matches the model EXACTLY. The section(s)
+          this feature answers for: {{model_scope_plan}}. Entities and value objects carry
+          the section's names (SAME names), the boundary is its Boundary block, states are
+          the lifecycle it describes;
           (b) EVERY invariant (BR-nnn) the spec cites has a named ENFORCEMENT POINT in the
           backend plan. An invariant nothing enforces is a HIGH gap; a plan that RESTATES
           what an invariant says instead of citing it by id is a gap too — the model is the
@@ -410,15 +468,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"
@@ -461,12 +541,20 @@ 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"
+
       - id: ask_repair
         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
@@ -519,7 +607,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
@@ -557,7 +646,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,
@@ -584,52 +675,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}}) — repair was skipped (see plan-analyze-report.md), or it did not converge in 3 passes. 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.)
 
@@ -653,10 +743,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.1.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,6 +124,7 @@ vars:
   test_ok: "false"
   test_tool: ""
   test_log: ""
+  test_excerpt: ""
   test_scoped: "false"
   test_ran: "false"
   test_matched: "false"
@@ -155,9 +156,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
@@ -182,7 +185,7 @@ workflow:
     action: verify_context
     require_non_empty: feature_dir
     on_empty: stop
-    on_empty_message: "No active feature. Run /appweaver select-feature first (pick the aggregate, e.g. Order), then re-run analyze-slice-delta."
+    on_empty_message: "No active feature. Run /appweaver select-feature first (pick the feature, e.g. Order or PatientRegistration), then re-run analyze-slice-delta."
 
   # 3. WHICH CHANGE. Same selection contract as plan, analyze-plan-delta and implement:
   #    cr-list enumerates the open changes (evidence = changes/<CR-id>/ on disk), a bare CR
@@ -316,6 +319,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 +418,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 +512,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
@@ -568,8 +576,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: