aw-spec-cli 0.1.28 → 0.1.30

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

@@ -28,6 +28,25 @@
 # Plus the OVERLAY BACKSTOP (the domain gate checklist over the constraints this change
 # touches), and the WAVE DISCIPLINE check below.
 #
+# ONLY THE LANES THE CHANGE NAMES. A change's delta-spec carries a **Lanes** line, and
+# `plan` writes a delta plan only for the lanes on it. A lane it leaves out is not gated, so
+# a backend-only change is not refused for having no frontend delta plan. A change with no
+# such line touches every lane.
+#
+# ONLY THE LANES YOU WORK ON ARE GATED (.appweaver/lane.json). The change menu lists only the
+# changes naming a working lane. A named lane you work on is gated: its delta plan must
+# exist, is checked and is repaired on approval. A named lane somebody else works on is
+# READ: its delta plan, once its developer has written it, is in context for check 3 and
+# nothing else, and a gap only that plan can close is reported for its developer rather than
+# repaired or stopped on. Its delta plan not existing yet is a note, not a refusal — check 3
+# waits until both halves are on disk.
+#
+# A SERVICE CHANGE THAT BREAKS A FRONTEND BINDING IS A WARNING (contract-impact). An
+# operation the service delta changes or removes that the master frontend plan binds to,
+# and that the change's frontend delta plan does not name, is reported by script before the
+# check — whatever lanes the change names. The frontend half may follow from its own
+# developer or in a follow-up change, so it never stops the gate.
+#
 # PREDECESSORS, NOT SIBLINGS. A wave is a dependency level. A LOWER-wave change is
 # committed to landing first, so this delta may be planned on top of it — and both halves
 # of each predecessor are in context, its model delta AND its delta-spec, because a plan
@@ -53,8 +72,8 @@
 # =============================================================================
 
 name: aw-spec-analyze-plan-delta
-description: The delta-spec↔delta-plan conformance gate for ONE open change — confirm its delta-backend-plan.md and delta-frontend-plan.md realise delta-spec.md, bind to each other's contract deltas, realise this change's domain model delta, and only MODIFY elements the masters really define. Checked against the EFFECTIVE model (domain-model.md plus this change's model delta plus every lower-wave predecessor's, whose delta-specs are in context too) and told, deterministically, which other open changes touch the same aggregates. Asks which open change it is gating when more than one is open; a CR id as the argument selects without a prompt. Does not modify the masters or close the change.
-version: 2.0.0
+description: The delta-spec↔delta-plan conformance gate for ONE open change — confirm its delta-backend-plan.md and delta-frontend-plan.md realise delta-spec.md, bind to each other's contract deltas, realise this change's domain model delta, and only MODIFY elements the masters really define. Checked against the EFFECTIVE model (domain-model.md plus this change's model delta plus every lower-wave predecessor's, whose delta-specs are in context too) and told, deterministically, which other open changes touch the same aggregates. Gates only the lanes the change names that you work on — the other developer's delta plan is read for the contract check, its gaps are reported for them, and its absence is a note. Warns, by script, when the service delta changes or removes an operation the frontend binds to and the frontend half does not follow. Asks which open change it is gating when more than one names your lane; a CR id as the argument selects without a prompt. Does not modify the masters or close the change.
+version: 2.2.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -87,9 +106,13 @@ vars:
   sibling_count: "0"
   overlap_report: ""
   # PER-LANE PRESENCE. A lane is gated when it is declared AND has a master plan (only
-  # then is there a base for a delta) AND this change has a delta plan for it. The engine
-  # has no compound conditions, so each AND is one ordered assignment.
-  be_gated: "false"         # declared AND a master plan exists
+  # then is there a base for a delta) AND the change's **Lanes** line names it AND this
+  # change has a delta plan for it. The engine has no compound conditions, so each AND is
+  # one ordered assignment.
+  cr_lanes_csv: ""
+  cr_touches_backend: "true"   # every lane until cr-paths answers
+  cr_touches_frontend: "true"
+  be_gated: "false"         # declared AND a master plan exists AND the change names it
   fe_gated: "false"
   be_present: "false"       # gated AND this change's delta plan exists ⇒ check it
   fe_present: "false"
@@ -97,7 +120,39 @@ vars:
   fe_missing: "false"
   deltas_ok: "true"
   any_lane: "false"
-  both_lanes: "false"       # both delta plans present ⇒ the contract check applies
+  both_lanes: "false"       # both delta plans in context ⇒ the contract check applies
+  # THE WORKING LANES (.appweaver/lane.json). A named lane is GATED only when it is worked;
+  # one that is not is SEEN (its delta plan read for check 3) or AWAITED (not written yet).
+  be_working: "false"
+  fe_working: "false"
+  working_lane: ""
+  work_lanes: ""            # the working lanes as a csv, for plan-gaps --lanes
+  working_kind: ""          # the one lane worked when one lane of two is; empty otherwise
+  report_file: ""           # delta-plan-analyze-report[.<working_kind>].md in the change
+  be_named: "false"         # declared AND a master AND the change names it
+  fe_named: "false"
+  be_seen: "false"          # named AND its delta plan on disk ⇒ in context
+  fe_seen: "false"
+  be_awaited: "false"       # named, not worked, no delta plan yet ⇒ the other developer's half
+  fe_awaited: "false"
+  no_awaited: "true"
+  awaited_txt: ""
+  apd_hidden_note: ""       # open changes naming only a lane not worked here
+  apd_hidden_csv: ""
+  apd_preselect_hidden: ""
+  preselect_visible: "true"
+  # THE GAP SPLIT (plan-gaps --lanes): a gap only the other developer's delta plan can close
+  # is listed for them and neither drives the repair nor the stop.
+  own_plan_gaps: "0"
+  own_routed: "0"
+  other_gaps: "0"
+  other_csv: ""
+  own_clear: "false"        # the only gaps left are the other developer's
+  gate_ok: "false"
+  no_other_gaps: "true"
+  # D4b — operations the service delta changes or removes that the frontend binds to.
+  impact_csv: ""
+  no_impact: "true"
   be_repair: "false"
   fe_repair: "false"
   backend_repair: "false"
@@ -126,6 +181,7 @@ workflow:
       - { name: lanes_declared, from: "$.declared" }
       - { name: be_declared,    from: "$.backend_declared" }
       - { name: fe_declared,    from: "$.frontend_declared" }
+      - { name: working_lane,   from: "$.working_lane" }
 
   - id: require_lane
     action: verify_context
@@ -166,6 +222,20 @@ workflow:
       - { name: be_declared, from: "$.backend_declared" }
       - { name: fe_declared, from: "$.frontend_declared" }
       - { name: fe_excluded, from: "$.frontend_feature_excluded" }
+      - { name: be_working,  from: "$.backend_working" }
+      - { name: fe_working,  from: "$.frontend_working" }
+      - { name: working_kind, from: "$.working_kind" }
+
+  # The working lanes as one csv for plan-gaps — an ordered pair of sets; an empty item
+  # left by the second is dropped by plan-gaps.
+  - id: work_lanes_be
+    condition: "{{be_working}} == true"
+    action: set
+    vars: { work_lanes: "backend" }
+  - id: work_lanes_fe
+    condition: "{{fe_working}} == true"
+    action: set
+    vars: { work_lanes: "{{work_lanes}},frontend" }
 
   - id: require_feature
     action: verify_context
@@ -180,25 +250,43 @@ workflow:
     on_false_message: "No spec.md for the current feature. Run /appweaver specify (and /appweaver plan) first."
 
   # 2. WHICH CHANGES ARE OPEN. The evidence is changes/<cr-id>/ on disk; a closed change
-  #    has moved to changes/archive/. `matched_label` resolves a CR id passed as the
+  #    has moved to changes/archive/. Only the changes naming a working lane on their
+  #    **Lanes** line are listed (`--lane`, last in the args so an empty value cannot be
+  #    mistaken for the next flag). `matched_label` resolves a CR id passed as the
   #    command's argument to the whole option string, so the pick below can auto-select it
   #    — the engine matches a preselection against the option text exactly.
   - id: cr_list
     action: execute_script
     script: { ref: actions }
     subcommand: cr-list
-    args: ["--feature-dir", "{{feature_dir}}", "--preselect", "{{USER_INPUT}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--preselect", "{{USER_INPUT}}", "--lane", "{{working_lane}}"]
     outputs:
       - { name: change_options, from: "$.select_options" }
       - { name: matched_label,  from: "$.matched_label" }
       - { name: has_changes,    from: "$.has_changes" }
       - { name: change_count,   from: "$.count" }
+      - { name: apd_hidden_csv,       from: "$.hidden_ids_csv" }
+      - { name: apd_preselect_hidden, from: "$.preselect_hidden" }
+
+  - id: preselect_hidden_flag
+    condition: "{{apd_preselect_hidden}} != "
+    action: set
+    vars: { preselect_visible: "false" }
+  - id: require_visible_change
+    action: verify_context
+    require_true: preselect_visible
+    on_false: stop
+    on_false_message: "Change {{apd_preselect_hidden}} does not touch your working lane `{{working_lane}}` (.appweaver/lane.json): its **Lanes** line names only the other lane, so there is no delta plan of yours to gate. Its own lane's developer gates it — or run /appweaver select-lane to work on that lane."
+  - id: hidden_note_set
+    condition: "{{apd_hidden_csv}} != "
+    action: set
+    vars: { apd_hidden_note: " Open for a lane you do not work on, and not listed: {{apd_hidden_csv}}." }
 
   - id: require_change
     action: verify_context
     require_true: has_changes
     on_false: stop
-    on_false_message: "No open change on this feature — there is no delta to gate. Run /appweaver specify <change> (which opens the change and writes its delta-spec + model delta), then /appweaver plan to author its delta plans, then re-run analyze-plan-delta. To re-anchor the MASTERS instead, run /appweaver analyze-plan."
+    on_false_message: "No open change on this feature names your working lane `{{working_lane}}` — there is no delta to gate.{{apd_hidden_note}} Run /appweaver specify <change> (which opens the change and writes its delta-spec + model delta), then /appweaver plan to author its delta plans, then re-run analyze-plan-delta. To re-anchor the MASTERS instead, run /appweaver analyze-plan."
 
   # 2b. Ask which one. A CR id in the argument auto-selects via matched_label; a feature
   #     with exactly one open change auto-confirms.
@@ -246,6 +334,11 @@ workflow:
       - { name: predecessor_count,         from: "$.predecessor_count" }
       - { name: sibling_count,             from: "$.sibling_count" }
       - { name: domain_model,              from: "$.domain_model" }
+      # The lanes this change touches — its delta-spec's **Lanes** line, every lane when it
+      # records none.
+      - { name: cr_lanes_csv,              from: "$.lanes_csv" }
+      - { name: cr_touches_backend,        from: "$.touches_backend" }
+      - { name: cr_touches_frontend,       from: "$.touches_frontend" }
 
   # 3b. WHICH OTHER OPEN CHANGES TOUCH THE SAME AGGREGATES. Deterministic: each pending
   #     model delta's `**Aggregates touched**:` header names the `## Aggregate:` sections
@@ -264,7 +357,8 @@ workflow:
       - { name: predecessor_overlaps, from: "$.predecessor_overlaps" }
 
   # 4. WHICH LANES ARE GATED. Declared AND a master plan exists (only then is there a base
-  #    for a delta) — then split on whether this change has that lane's delta plan.
+  #    for a delta) AND named on the change's **Lanes** line — then split on whether this
+  #    change has that lane's delta plan.
   #    A lane whose MASTER was bootstrapped in the same `plan` run has no delta plan by
   #    design: it was authored from the whole spec and there is nothing for a delta to
   #    add. Keying on the master's presence is what keeps that case out of the gate.
@@ -276,6 +370,56 @@ workflow:
     condition: "{{frontend_plan_exists}} == true"
     action: set
     vars: { fe_gated: "{{fe_declared}}" }
+  # A lane the change's **Lanes** line leaves out has no part in it: no delta plan is
+  # written for it, so none is required here.
+  - id: be_not_in_change
+    condition: "{{cr_touches_backend}} == false"
+    action: set
+    vars: { be_gated: "false" }
+  - id: fe_not_in_change
+    condition: "{{cr_touches_frontend}} == false"
+    action: set
+    vars: { fe_gated: "false" }
+  # NAMED is kept before the working-lane knockdown: a named lane somebody else works on is
+  # read, not gated.
+  - id: be_named_set
+    action: set
+    vars: { be_named: "{{be_gated}}" }
+  - id: fe_named_set
+    action: set
+    vars: { fe_named: "{{fe_gated}}" }
+  - id: be_not_worked
+    condition: "{{be_working}} == false"
+    action: set
+    vars: { be_gated: "false" }
+  - id: fe_not_worked
+    condition: "{{fe_working}} == false"
+    action: set
+    vars: { fe_gated: "false" }
+  - id: be_flag_seen
+    condition: "{{delta_backend_plan_exists}} == true"
+    action: set
+    vars: { be_seen: "{{be_named}}" }
+  - id: fe_flag_seen
+    condition: "{{delta_frontend_plan_exists}} == true"
+    action: set
+    vars: { fe_seen: "{{fe_named}}" }
+  - id: be_flag_awaited
+    condition: "{{delta_backend_plan_exists}} == false"
+    action: set
+    vars: { be_awaited: "{{be_named}}" }
+  - id: be_awaited_mine
+    condition: "{{be_working}} == true"
+    action: set
+    vars: { be_awaited: "false" }
+  - id: fe_flag_awaited
+    condition: "{{delta_frontend_plan_exists}} == false"
+    action: set
+    vars: { fe_awaited: "{{fe_named}}" }
+  - id: fe_awaited_mine
+    condition: "{{fe_working}} == true"
+    action: set
+    vars: { fe_awaited: "false" }
   - id: be_flag_present
     condition: "{{delta_backend_plan_exists}} == true"
     action: set
@@ -304,11 +448,47 @@ workflow:
     action: set
     vars: { deltas_ok: "false" }
 
+  # The other developer's half, not written yet: said, never refused. Only a lane that is
+  # not worked can be awaited, so at most one is.
+  - id: awaited_be_txt
+    condition: "{{be_awaited}} == true"
+    action: set
+    vars: { awaited_txt: "backend", no_awaited: "false" }
+  - id: awaited_fe_txt
+    condition: "{{fe_awaited}} == true"
+    action: set
+    vars: { awaited_txt: "frontend", no_awaited: "false" }
+  - id: note_awaited
+    action: verify_context
+    require_true: no_awaited
+    on_false: continue
+    on_false_message: "NOTE — change {{cr_id}} also names the {{awaited_txt}} lane, whose developer has not written its delta plan yet. This run gates your half only; the contract between the two halves (check 3) is checked once both delta plans are on disk."
+
+  # D4b. What the service delta changes or removes that the frontend binds to, by script.
+  - id: contract_impact
+    condition: "{{delta_backend_plan_exists}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-impact
+    args: ["--delta-backend", "{{delta_backend_plan}}", "--frontend-plan", "{{frontend_plan}}", "--delta-frontend", "{{delta_frontend_plan}}"]
+    outputs:
+      - { name: impact_csv, from: "$.unaddressed_csv" }
+  - id: impact_flag
+    condition: "{{impact_csv}} != "
+    action: set
+    vars: { no_impact: "false" }
+  - id: warn_contract_impact
+    action: verify_context
+    require_true: no_impact
+    on_false: continue
+    on_false_message: "WARNING — change {{cr_id}} changes or removes operation(s) the frontend plan binds to, and its frontend delta plan does not carry the matching change: {{impact_csv}}. The change names {{cr_lanes_csv}}. Until the frontend follows, it calls an operation the service is changing: the frontend half of this change carries it (if the change names only the backend, widen it with `.appweaver/scripts/bash/aw-spec-actions.sh cr-lanes --cr-id {{cr_id}} --set both`, then the frontend developer runs /appweaver plan {{cr_id}}), or a follow-up change does."
+
   - id: require_deltas
     action: verify_context
     require_true: deltas_ok
     on_false: stop
-    on_false_message: "Change {{cr_id}} has no delta plan for a lane that has a master plan (backend missing={{be_missing}} · frontend missing={{fe_missing}}). Run /appweaver plan {{cr_id}} — it authors that change's delta plan for every lane whose master exists, against the delta spec, the effective model and the feature's real source files. This gate validates a delta plan; it does not write one."
+    on_false_message: "Change {{cr_id}} has no delta plan for a lane it touches ({{cr_lanes_csv}}) that has a master plan (backend missing={{be_missing}} · frontend missing={{fe_missing}}). Run /appweaver plan {{cr_id}} — it authors that change's delta plan for every lane the change names whose master exists, against the delta spec, the effective model and the feature's real source files. This gate validates a delta plan; it does not write one."
 
   - id: any_backend
     condition: "{{be_present}} == true"
@@ -325,15 +505,17 @@ workflow:
     on_false: stop
     on_false_message: "Change {{cr_id}} has no delta plan to gate on any declared lane. Run /appweaver plan {{cr_id}} first."
 
-  # Check 3 needs BOTH delta plans. One more ordered assignment.
+  # Check 3 needs BOTH delta plans in context — gated or only read. One more ordered
+  # assignment.
   - id: flag_both_lanes
-    condition: "{{be_present}} == true"
+    condition: "{{be_seen}} == true"
     action: set
-    vars: { both_lanes: "{{fe_present}}" }
+    vars: { both_lanes: "{{fe_seen}}" }
 
   # Bind the CONTEXT paths per lane: the master (the base a MODIFIED element must name) for
-  # a gated lane, the delta plan for a present one. A lane that is neither leaves both
-  # empty, so its documents never reach the payload.
+  # a gated lane, the delta plan — and its master — for a lane whose delta plan is in
+  # context. A lane that is neither leaves both empty, so its documents never reach the
+  # payload.
   - id: be_master_ctx_path
     condition: "{{be_gated}} == true"
     action: set
@@ -343,13 +525,23 @@ workflow:
     action: set
     vars: { fe_master_ctx: "{{frontend_plan}}" }
   - id: be_delta_ctx_path
-    condition: "{{be_present}} == true"
+    condition: "{{be_seen}} == true"
     action: set
     vars: { be_delta_ctx: "{{delta_backend_plan}}" }
   - id: fe_delta_ctx_path
-    condition: "{{fe_present}} == true"
+    condition: "{{fe_seen}} == true"
     action: set
     vars: { fe_delta_ctx: "{{delta_frontend_plan}}" }
+  # A read lane's master too: check 3(d) holds the experience delta to what the master
+  # frontend plan uses, whichever developer runs it.
+  - id: be_master_ctx_seen
+    condition: "{{be_seen}} == true"
+    action: set
+    vars: { be_master_ctx: "{{backend_plan}}" }
+  - id: fe_master_ctx_seen
+    condition: "{{fe_seen}} == true"
+    action: set
+    vars: { fe_master_ctx: "{{frontend_plan}}" }
 
   # 4b. Load the domain GATE overlays (the domain-rule-bindings `/aw-spec-gate` checklist)
   #     as the conformance checklist — VALIDATION input only, NEVER authoring. analyze sees
@@ -398,6 +590,17 @@ workflow:
       - { path: "{{fe_master_ctx}}", optional: true }     #   every MODIFIED element must name
       - { path: "{{domain_model}}", optional: true }      # the canonical model (READ ONLY)
 
+  # The report "Report and Skip" writes. A developer working one lane of two writes their
+  # own, delta-plan-analyze-report.<lane>.md, so two developers gating the same change never
+  # rewrite each other's report; a developer on every lane writes delta-plan-analyze-report.md.
+  - id: report_file_set
+    action: set
+    vars: { report_file: "{{cr_dir}}/delta-plan-analyze-report.md" }
+  - id: report_file_lane
+    condition: "{{working_kind}} != "
+    action: set
+    vars: { report_file: "{{cr_dir}}/delta-plan-analyze-report.{{working_kind}}.md" }
+
   # 7. Conformance + REPAIR loop (the delta spec is the anchor): check → REPORT gaps +
   #    ASK → Repair on approval → re-check; "Report and Skip" writes the report + stops.
   #    Bounded (3×). The repair is PER LANE, so a frontend drift never rewrites a
@@ -416,8 +619,14 @@ workflow:
           delta-spec.md is the ANCHOR for change {{cr_id}} (wave {{wave}}). Gate this
           change's DELTA PLANS against it, against the masters they change, and against the
           effective domain model, and list EVERY drift as a gap. Run the checks that apply
-          — service delta present: {{be_present}}, experience delta present: {{fe_present}},
-          both present: {{both_lanes}}. A check for an absent lane is SKIPPED, not failed.
+          — service delta in context: {{be_seen}}, experience delta in context: {{fe_seen}},
+          both: {{both_lanes}}. A check for an absent lane is SKIPPED, not failed.
+          WHICH DELTA PLANS ARE GATED: service {{be_present}}, experience {{fe_present}} —
+          the lanes the developer running this works on. Run checks 1, 2, 4 and 5 for a
+          GATED delta plan only. A delta plan in context and NOT gated belongs to another
+          developer: read it for check 3, where the two halves of the contract meet, and
+          nothing else. Every gap still carries the `lane` whose document must change to
+          close it, even when that lane is not gated here.
 
           CHECK 1 — delta-spec.md → delta-backend-plan.md (when it is in context):
           (a) every ADDED / MODIFIED delta-spec item — FR / BR / CN- / DC- / IC- / user
@@ -533,6 +742,41 @@ workflow:
       - id: conform_break
         action: break
         condition: "{{analyze_ok}} == true"
+
+      # WHO CAN CLOSE EACH GAP. A gap tagged with a lane this developer does not work on is
+      # the other developer's: it is listed under `other` and, when nothing else is left,
+      # ends the loop without a repair. A LIFT-FAILURE is shared whatever its lane, so it
+      # keeps the gate red. With every lane worked nothing is `other` and the loop runs as
+      # it always has.
+      - id: classify_gaps
+        action: execute_script
+        script: { ref: actions }
+        subcommand: plan-gaps
+        args: ["--gaps", "{{analyze_gaps}}", "--lanes", "{{work_lanes}}"]
+        outputs:
+          - { name: own_plan_gaps, from: "$.plan_gaps" }
+          - { name: own_routed,    from: "$.routed_gaps" }
+          - { name: other_gaps,    from: "$.other_gaps" }
+          - { name: other_csv,     from: "$.other_csv" }
+      - id: own_clear_reset
+        action: set
+        vars: { own_clear: "false" }
+      - id: own_clear_raise
+        condition: "{{other_gaps}} != 0"
+        action: set
+        vars: { own_clear: "true" }
+      - id: own_clear_plan
+        condition: "{{own_plan_gaps}} != 0"
+        action: set
+        vars: { own_clear: "false" }
+      - id: own_clear_routed
+        condition: "{{own_routed}} != 0"
+        action: set
+        vars: { own_clear: "false" }
+      - id: own_clear_break
+        action: break
+        condition: "{{own_clear}} == true"
+
       - id: ask_repair
         action: ask
         prompt: |
@@ -546,7 +790,7 @@ workflow:
         condition: "{{repair_choice}} == Report and Skip"
         action: agent_author
         include_standards: false
-        output_target: { type: file, path: "{{cr_dir}}/delta-plan-analyze-report.md" }
+        output_target: { type: file, path: "{{report_file}}" }
         task: |
           Write a Delta Plan Analyze Report to the output from these delta-spec↔delta-plan
           conformance gaps (the delta spec is the ANCHOR; the user chose to skip repair):
@@ -665,11 +909,27 @@ workflow:
             headers — scripts stamp those.
           Return the COMPLETE updated delta plan content only.
 
+  # THE STOP. Two independent raises: nothing drifts, or what drifts is only the other
+  # developer's to close — reported for them below.
+  - id: gate_ok_conformant
+    condition: "{{analyze_ok}} == true"
+    action: set
+    vars: { gate_ok: "true" }
+  - id: gate_ok_others_only
+    condition: "{{own_clear}} == true"
+    action: set
+    vars: { gate_ok: "true", no_other_gaps: "false" }
+  - id: note_other_gaps
+    action: verify_context
+    require_true: no_other_gaps
+    on_false: continue
+    on_false_message: "NOTE — your half of change {{cr_id}} passes. What is left is in the delta plan of a lane you do not work on, for its developer to close (their own analyze-plan-delta {{cr_id}} repairs it): {{other_csv}}"
+
   - id: analyze_gate
     action: verify_context
-    require_true: analyze_ok
+    require_true: gate_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' — 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."
+    on_false_message: "The delta plans for {{cr_id}} do not realise the delta spec (gaps: {{analyze_gaps}}) — repair was skipped (see {{report_file}}), 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
@@ -690,8 +950,13 @@ outputs:
   wave: "{{wave}}"
   delta_backend_plan: "{{delta_backend_plan}}"    # empty when that lane has no delta plan
   delta_frontend_plan: "{{delta_frontend_plan}}"
-  conformant: "{{analyze_ok}}"
+  conformant: "{{analyze_ok}}"                     # every check passed, the other developer's half included; false on a run that finishes means only other_lane_gaps are left
   gaps: "{{analyze_gaps}}"
   overlaps: "{{overlap_report}}"
+  working_lane: "{{working_lane}}"                 # the developer's working lane(s) — .appweaver/lane.json
+  gated_backend: "{{be_present}}"                  # checked and repaired by this run
+  gated_frontend: "{{fe_present}}"
+  other_lane_gaps: "{{other_csv}}"                 # gaps only the other developer's delta plan can close
+  contract_impact: "{{impact_csv}}"                # operations the service delta changes or removes that the frontend still binds to
   note: "Gated change {{cr_id}} (wave {{wave}}) against its delta spec, the masters it changes, and the EFFECTIVE model — domain-model.md plus this change's model delta plus the {{predecessor_count}} predecessor change(s) from LOWER waves (each one's model delta and its delta-spec). Same-wave changes are visible but never assumed: {{sibling_count}} open at the same or a higher wave, overlapping this one on — {{overlap_report}}. The masters and the model were READ, never written."
   next: "/appweaver implement {{cr_id}} → build → analyze-slice-delta → finalize-delta → analyze-slice → close-delta   (implement is one command for both lanes and both paths — passing the id above skips its 'which change' prompt; the delta plans realise the delta spec; the change stays OPEN through finalize-delta's merge and analyze-slice's verification, and only close-delta archives it and bumps the version)"