aw-spec-cli 0.1.28 → 0.1.30

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

@@ -57,6 +57,22 @@
 # repair loops stay in analyze-slice, where the merged master is the anchor and the job is
 # fixing what is BROKEN rather than building what is ABSENT.
 #
+# ONLY THE LANES THE CHANGE NAMES THAT YOU WORK ON ARE GATED (.appweaver/lane.json). The
+# change menu lists only the changes whose **Lanes** line names a working lane. A lane is
+# gated when the change names it, you work on it and the change has its delta plan, and each
+# gated lane runs its OWN tests (`test-run --kind`), so a backend developer's gate is never
+# failed by the frontend's suite. A named lane somebody else works on is gated by that
+# developer's own run; this one says so in a note and does not wait for it.
+#
+# EACH GATED LANE'S RESULT IS RECORDED in the change's directory, pass or fail, as
+# `.aw-slice-gate.<lane>.json` (slice-gate-stamp), and is committed with the change. pass =
+# no test of the lane failed AND its requirement checks met; a lane that declares no test
+# command is green with nothing run, and the record's tests_ran says so. Two developers
+# write two different files, so their results never collide, and together they are the
+# record of which lanes of the change were shown to be built. The REPORT is split the same
+# way: a developer working one lane of two writes delta-slice-analyze-report.<lane>.md, and
+# a developer on every lane writes delta-slice-analyze-report.md.
+#
 # NO NEW RULE-MAP HEADING. It loads `## /aw-spec-analyze-slice` — the same testing +
 # coding-standards set its master twin reads — so no project has to add configuration to
 # get this gate. The DOMAIN gate overlays are deliberately NOT loaded: full domain
@@ -70,8 +86,8 @@
 # =============================================================================
 
 name: aw-spec-analyze-slice-delta
-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."
+version: 1.3.0
+description: "The delta-spec↔delta-code gate — verify that the open change DOES WHAT IT WAS ASKED TO DO, before it reaches the master documents. delta-spec.md is the anchor, exactly as it is for analyze-plan-delta. Asks which open change it is gating (only the changes naming a lane you work on are listed) and gates only the lanes the change names that you work on. Each gated lane runs its own tests (the first execution on the change path, since build only compiles), then its code and paired tests are evaluated against the change's REQUIREMENTS — every ADDED or MODIFIED delta-spec item realised in code, every one covered by a test that cites its id, every invariant the model delta adds actually enforced — with the delta plan in context as the map from requirement to code and cross-checked in its own right, so an element the plan promised and nobody built is caught too. Each gated lane's pass or fail is recorded in the change as .aw-slice-gate.<lane>.json. The dynamic twin of analyze-plan-delta and the delta twin of analyze-slice, which cannot see a missing implementation because a behaviour that was never built leaves no failing test. Verify-only — it reports each finding with the command that closes it and stops; it generates no code and repairs nothing."
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -109,27 +125,71 @@ vars:
   delta_frontend_plan: ""
   delta_frontend_plan_exists: "false"
   domain_model: ""
-  # WHICH LANES THIS GATE CHECKS — a lane is gated when it is DECLARED and this change has
-  # a delta plan for it. An experience-untouched change has no frontend delta plan, and
-  # skipping that lane's checks is correct rather than a pass by omission. Each AND is an
-  # ordered assignment; the engine has no compound conditions.
+  # WHICH LANES THIS GATE CHECKS — a lane is gated when it is DECLARED for this feature, the
+  # change's **Lanes** line NAMES it, this developer WORKS on it (.appweaver/lane.json) and
+  # the change has a delta plan for it. An experience-untouched change has no frontend delta
+  # plan, and skipping that lane's checks is correct rather than a pass by omission. Each AND
+  # is an ordered assignment; the engine has no compound conditions.
   be_declared: "false"
   fe_declared: "false"
   fe_excluded: "false"        # this feature records no surface in the declared frontend lane (feature-lanes)
+  be_working: "false"
+  fe_working: "false"
+  working_lane: ""
+  working_kind: ""            # the one lane worked when one lane of two is; empty otherwise
+  working_root: ""            # the working lane's root and test path when one lane of two is worked
+  working_test_path: ""
+  under_note: ""
+  report_file: ""             # delta-slice-analyze-report[.<working_kind>].md in the change
+  cr_lanes_csv: ""
+  cr_touches_backend: "true"  # every lane until cr-paths answers
+  cr_touches_frontend: "true"
+  be_named: "false"           # declared AND the change names it
+  fe_named: "false"
+  be_awaited: "false"         # named, not worked ⇒ gated by the developer who works on it
+  fe_awaited: "false"
+  no_awaited: "true"
+  awaited_txt: ""
+  asd_hidden_note: ""         # open changes naming only a lane not worked here
+  asd_hidden_csv: ""
+  asd_preselect_hidden: ""
+  preselect_visible: "true"
   be_gated: "false"
   fe_gated: "false"
   any_lane: "false"
   # Slice evidence.
   source_files: []
   source_count: "0"
-  test_ok: "false"
-  test_tool: ""
-  test_log: ""
-  test_excerpt: ""
-  test_scoped: "false"
-  test_ran: "false"
-  test_matched: "false"
-  # Verdict.
+  # Each gated lane's own test run. `*_test_vote` is what a lane casts into test_ok — its
+  # result when gated, "true" when not — so a lane that was not gated never votes, and a
+  # gated lane whose run returned nothing votes red.
+  be_test_ok: "false"
+  be_test_tool: ""
+  be_test_log: ""
+  be_test_excerpt: ""
+  be_test_scoped: "false"
+  be_test_ran: "false"
+  be_test_matched: "false"
+  be_test_vote: "true"
+  fe_test_ok: "false"
+  fe_test_tool: ""
+  fe_test_log: ""
+  fe_test_excerpt: ""
+  fe_test_scoped: "false"
+  fe_test_ran: "false"
+  fe_test_matched: "false"
+  fe_test_vote: "true"
+  test_ok: "false"            # every gated lane's tests green
+  # Each lane's state in words, for the report and the stop message; a gated lane's ends on
+  # its recorded verdict (pass | fail).
+  be_state: "not gated — no backend lane for this feature"
+  fe_state: "not gated — no frontend lane for this feature"
+  be_verdict: ""
+  fe_verdict: ""
+  # Verdict. `*_req_vote` is what a lane casts into requirements_ok: "true" when it was not
+  # gated; when it was, true only on its check's explicit ok=true.
+  be_req_vote: "true"
+  fe_req_vote: "true"
   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.
@@ -199,7 +259,8 @@ workflow:
   # active_version.json for a service-only slice in a repo that also has a UI. Re-read with
   # --feature-dir so a lane the feature records no surface in is absent here: its code is
   # not gated against a plan it never had. With no feature resolved the argument is dropped
-  # and the repo's answer stands.
+  # and the repo's answer stands. The WORKING lanes are read here too, so a lane the feature
+  # records no surface in is not worked either.
   - id: feature_lanes
     action: execute_script
     on_error: continue
@@ -207,9 +268,15 @@ workflow:
     subcommand: lane-resolve
     args: ["--feature-dir", "{{feature_dir}}"]
     outputs:
-      - { name: be_declared, from: "$.backend_declared" }
-      - { name: fe_declared, from: "$.frontend_declared" }
-      - { name: fe_excluded, from: "$.frontend_feature_excluded" }
+      - { 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_lane,      from: "$.working_lane" }
+      - { name: working_kind,      from: "$.working_kind" }
+      - { name: working_root,      from: "$.working_root" }
+      - { name: working_test_path, from: "$.working_test_path" }
 
   - id: require_feature
     action: verify_context
@@ -221,26 +288,44 @@ workflow:
   #    cr-list enumerates the open changes (evidence = changes/<CR-id>/ on disk), a bare CR
   #    id in the argument auto-selects, one open change auto-confirms, and the pick is
   #    ACTIVATED so finalize-delta and close-delta act on the change this gate cleared.
+  #    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).
   - 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: asd_hidden_csv,       from: "$.hidden_ids_csv" }
+      - { name: asd_preselect_hidden, from: "$.preselect_hidden" }
+
+  - id: preselect_hidden_flag
+    condition: "{{asd_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 {{asd_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 code 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: "{{asd_hidden_csv}} != "
+    action: set
+    vars: { asd_hidden_note: " Open for a lane you do not work on, and not listed: {{asd_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. This is the CHANGE path's gate; on the bootstrap path the whole slice is gated by /appweaver analyze-slice after build. A change is opened by /appweaver specify."
+    on_false_message: "No open change on this feature names your working lane `{{working_lane}}` — there is no delta to gate.{{asd_hidden_note}} This is the CHANGE path's gate; on the bootstrap path the whole slice is gated by /appweaver analyze-slice after build. A change is opened by /appweaver specify."
 
   - id: pick_change
     action: user_select
-    prompt: "Which open change is being gated? This checks that the change was actually BUILT, before finalize-delta merges it into the masters."
+    prompt: "Which open change is being gated? This checks that the change was actually BUILT, before finalize-delta merges it into the masters.{{asd_hidden_note}}"
     options_from_variable: change_options
     preselect_from: matched_label
     single_option_confirm: true
@@ -271,16 +356,70 @@ workflow:
       - { name: delta_frontend_plan_exists, from: "$.delta_frontend_plan_exists" }
       - { name: wave,                      from: "$.wave" }
       - { name: domain_model,              from: "$.domain_model" }
-
-  # 3a. WHICH LANES ARE GATED — declared AND this change has a delta plan for that lane.
+      # 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" }
+
+  # 3a. WHICH LANES ARE GATED. Declared for this feature AND named on the change's **Lanes**
+  #     line (NAMED). A named lane somebody else works on is AWAITED — its own developer
+  #     gates it. A named lane you work on is GATED when this change has its delta plan.
+  - id: be_named_set
+    action: set
+    vars: { be_named: "{{be_declared}}" }
+  - id: fe_named_set
+    action: set
+    vars: { fe_named: "{{fe_declared}}" }
+  - id: be_not_in_change
+    condition: "{{cr_touches_backend}} == false"
+    action: set
+    vars: { be_named: "false" }
+  - id: fe_not_in_change
+    condition: "{{cr_touches_frontend}} == false"
+    action: set
+    vars: { fe_named: "false" }
+  - id: be_flag_awaited
+    condition: "{{be_working}} == false"
+    action: set
+    vars: { be_awaited: "{{be_named}}" }
+  - id: fe_flag_awaited
+    condition: "{{fe_working}} == false"
+    action: set
+    vars: { fe_awaited: "{{fe_named}}" }
   - id: be_gated_flag
     condition: "{{delta_backend_plan_exists}} == true"
     action: set
-    vars: { be_gated: "{{be_declared}}" }
+    vars: { be_gated: "{{be_named}}" }
   - id: fe_gated_flag
     condition: "{{delta_frontend_plan_exists}} == true"
     action: set
-    vars: { fe_gated: "{{fe_declared}}" }
+    vars: { fe_gated: "{{fe_named}}" }
+  - 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" }
+
+  # The other developer's half: said, never waited for. 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, which you do not work on (.appweaver/lane.json). Its developer gates that half in their own run, and its result is recorded beside yours in {{cr_dir}}/.aw-slice-gate.{{awaited_txt}}.json. This run tests, checks and records your half only."
+
   - id: any_lane_be
     condition: "{{be_gated}} == true"
     action: set
@@ -294,7 +433,7 @@ workflow:
     action: verify_context
     require_true: any_lane
     on_false: stop
-    on_false_message: "Change {{cr_id}} has no delta plan for any declared lane — backend declared {{be_declared}} (delta plan {{delta_backend_plan_exists}}), frontend declared {{fe_declared}} (delta plan {{delta_frontend_plan_exists}}). There is nothing to gate the code against. Run /appweaver plan {{cr_id}} to author the delta plans, then analyze-plan-delta → implement → build, and gate it here."
+    on_false_message: "Change {{cr_id}} has no delta plan for a lane it names that you work on — it names `{{cr_lanes_csv}}`, you work on `{{working_lane}}` (.appweaver/lane.json); backend declared {{be_declared}} (delta plan {{delta_backend_plan_exists}}), frontend declared {{fe_declared}} (delta plan {{delta_frontend_plan_exists}}). There is nothing of yours to gate the code against. Run /appweaver plan {{cr_id}} to author the delta plans, then analyze-plan-delta → implement → build, and gate it here."
 
   # 4. THE SLICE'S REAL SOURCE FILES, from its OKF concept — the same resolution
   #    analyze-slice uses. They arrive as a PATH LIST and the check steps declare
@@ -303,21 +442,27 @@ workflow:
   #    use-case or an endpoint and never a file. That is why this gate is a model pass over
   #    real files rather than a deterministic existence check — the same reason design-paths
   #    was retired when the plan stopped carrying ```lang path=…``` fences.
+  #    `--under` keeps the working lane's own two subtrees when the developer works on one
+  #    lane of two.
   - id: concept_paths
     action: execute_script
     on_error: continue
     script: { ref: xref }
     subcommand: concept-paths
-    args: ["--feature-dir", "{{feature_dir}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{working_root}}", "--under", "{{working_test_path}}"]
     outputs:
       - { name: source_files, from: "$.paths" }
       - { name: source_count, from: "$.count" }
 
+  - id: under_note_set
+    condition: "{{working_root}} != "
+    action: set
+    vars: { under_note: " under your working lane's folders (`{{working_root}}`, `{{working_test_path}}`)" }
   - id: require_source
     action: verify_context
     require_non_empty: source_files
     on_empty: stop
-    on_empty_message: "The OKF concept for {{feature}} lists no source files, so there is no implementation to gate. Either /appweaver implement has not run for change {{cr_id}} yet, or it ran and reported no files. Run /appweaver implement {{cr_id}} → build, then re-run this gate."
+    on_empty_message: "The OKF concept for {{feature}} lists no source files{{under_note}}, so there is no implementation to gate. Either /appweaver implement has not run for change {{cr_id}} yet, or it ran and reported no files. Run /appweaver implement {{cr_id}} → build, then re-run this gate."
 
   # 5. Pre-execution hooks.
   - id: resolve_pre_hooks
@@ -338,19 +483,22 @@ workflow:
   # scope=slice: this feature's tests only. Referring aggregates are the downstream fence's
   # subject in finalize-delta and the integrity pass's in analyze-slice; this gate is about
   # THIS change.
+  # ONE RUN PER GATED LANE (`--kind`), so each lane's result is its own: a lane is not failed
+  # by the other lane's suite, and a lane that is not gated runs nothing.
   # NO FIX LOOP, deliberately — see the header. A red fence is reported and stops.
-  - id: run_tests
+  - id: run_tests_backend
+    condition: "{{be_gated}} == true"
     action: execute_script
     on_error: continue
     script: { ref: actions }
     subcommand: test-run
-    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice"]
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "backend"]
     outputs:
-      - { 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" }
+      - { name: be_test_ok,      from: "$.fence_green" }
+      - { name: be_test_tool,    from: "$.tool" }
+      - { name: be_test_log,     from: "$.log_tail" }
+      - { name: be_test_excerpt, from: "$.failing_excerpt" }   # the lines that NAME the failure
+      - { name: be_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
       # its own ladder warns about. It is not made fatal here (that would fail every project
@@ -358,8 +506,45 @@ workflow:
       # but it IS reported, so "BUILT ✓" is never read as "the tests passed" when nothing
       # ran. The requirement checks below are what actually answer whether the change
       # does what it asked for, and they do not depend on a suite existing.
-      - { name: test_ran,     from: "$.ran" }
-      - { name: test_matched, from: "$.matched" }
+      - { name: be_test_ran,     from: "$.ran" }
+      - { name: be_test_matched, from: "$.matched" }
+  - id: run_tests_frontend
+    condition: "{{fe_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-run
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "frontend"]
+    outputs:
+      - { name: fe_test_ok,      from: "$.fence_green" }
+      - { name: fe_test_tool,    from: "$.tool" }
+      - { name: fe_test_log,     from: "$.log_tail" }
+      - { name: fe_test_excerpt, from: "$.failing_excerpt" }
+      - { name: fe_test_scoped,  from: "$.scoped" }
+      - { name: fe_test_ran,     from: "$.ran" }
+      - { name: fe_test_matched, from: "$.matched" }
+
+  # test_ok = every gated lane's tests green — a raise and two knock-downs, each lane voting
+  # only when it was gated.
+  - id: be_test_vote_set
+    condition: "{{be_gated}} == true"
+    action: set
+    vars: { be_test_vote: "{{be_test_ok}}" }
+  - id: fe_test_vote_set
+    condition: "{{fe_gated}} == true"
+    action: set
+    vars: { fe_test_vote: "{{fe_test_ok}}" }
+  - id: tests_seed
+    action: set
+    vars: { test_ok: "true" }
+  - id: tests_clear_backend
+    condition: "{{be_test_vote}} == false"
+    action: set
+    vars: { test_ok: "false" }
+  - id: tests_clear_frontend
+    condition: "{{fe_test_vote}} == false"
+    action: set
+    vars: { test_ok: "false" }
 
   # ══════ PASS 2 — REQUIREMENTS. Does the code do what the change asked for? ══════
   # THE REQUIREMENTS ARE THE ANCHOR; the plan is the map; the masters are read-only context
@@ -564,16 +749,34 @@ workflow:
 
   # ═══════════════════════════ THE VERDICT ═══════════════════════════
   # requirements_ok = every GATED lane passed. Expressed as a raise-then-knock-down chain,
-  # because the engine has no compound conditions and an ungated lane must not vote.
+  # because the engine has no compound conditions and an ungated lane must not vote. A gated
+  # lane votes met only on an explicit ok=true: a check that answered without `ok` votes not
+  # met, the same reading its .aw-slice-gate record gives it.
+  - id: be_req_vote_gated
+    condition: "{{be_gated}} == true"
+    action: set
+    vars: { be_req_vote: "false" }
+  - id: be_req_vote_met
+    condition: "{{be_ok}} == true"
+    action: set
+    vars: { be_req_vote: "true" }
+  - id: fe_req_vote_gated
+    condition: "{{fe_gated}} == true"
+    action: set
+    vars: { fe_req_vote: "false" }
+  - id: fe_req_vote_met
+    condition: "{{fe_ok}} == true"
+    action: set
+    vars: { fe_req_vote: "true" }
   - id: requirements_seed
     action: set
     vars: { requirements_ok: "true" }
   - id: requirements_clear_backend
-    condition: "{{be_ok}} == false"
+    condition: "{{be_req_vote}} == false"
     action: set
     vars: { requirements_ok: "false" }
   - id: requirements_clear_frontend
-    condition: "{{fe_ok}} == false"
+    condition: "{{fe_req_vote}} == false"
     action: set
     vars: { requirements_ok: "false" }
 
@@ -601,16 +804,84 @@ workflow:
       - { 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.
+  # gate_ok = every gated lane's tests green AND every gated lane's requirements are met.
   - id: gate_flag
     condition: "{{test_ok}} == true"
     action: set
     vars: { gate_ok: "{{requirements_ok}}" }
 
+  # EACH GATED LANE'S RESULT, RECORDED IN THE CHANGE as .aw-slice-gate.<lane>.json — pass
+  # when no test of the lane failed and its requirement checks are met, else fail, with
+  # whether a suite actually ran. It is written before the gate below stops, so a red result
+  # replaces an earlier green one instead of leaving it standing.
+  - id: stamp_backend
+    condition: "{{be_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: slice-gate-stamp
+    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{be_test_ok}}", "--tests-ran", "{{be_test_ran}}", "--requirements-ok", "{{be_req_vote}}", "--findings", "{{be_gaps}}", "--lane", "backend"]
+    outputs:
+      - { name: be_verdict, from: "$.verdict" }
+  - id: stamp_frontend
+    condition: "{{fe_gated}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: slice-gate-stamp
+    args: ["--cr-id", "{{cr_id}}", "--feature-dir", "{{feature_dir}}", "--tests-green", "{{fe_test_ok}}", "--tests-ran", "{{fe_test_ran}}", "--requirements-ok", "{{fe_req_vote}}", "--findings", "{{fe_gaps}}", "--lane", "frontend"]
+    outputs:
+      - { name: fe_verdict, from: "$.verdict" }
+
+  # EACH LANE'S STATE IN WORDS. Ordered from the least to the most specific; a gated lane
+  # ends on its test result, its requirement verdict and what was recorded.
+  - id: be_state_unnamed
+    condition: "{{be_declared}} == true"
+    action: set
+    vars: { be_state: "not gated — the change's **Lanes** line does not name it" }
+  - id: be_state_no_plan
+    condition: "{{be_named}} == true"
+    action: set
+    vars: { be_state: "not gated — this change has no backend delta plan" }
+  - id: be_state_awaited
+    condition: "{{be_awaited}} == true"
+    action: set
+    vars: { be_state: "not gated here — you do not work on it, and its own developer gates it" }
+  - id: be_state_gated
+    condition: "{{be_gated}} == true"
+    action: set
+    vars: { be_state: "gated — tests green={{be_test_ok}} (tool `{{be_test_tool}}`, actually ran={{be_test_ran}}), requirements met={{be_req_vote}}, recorded `{{be_verdict}}` in .aw-slice-gate.backend.json" }
+  - id: fe_state_unnamed
+    condition: "{{fe_declared}} == true"
+    action: set
+    vars: { fe_state: "not gated — the change's **Lanes** line does not name it" }
+  - id: fe_state_no_plan
+    condition: "{{fe_named}} == true"
+    action: set
+    vars: { fe_state: "not gated — this change has no frontend delta plan" }
+  - id: fe_state_awaited
+    condition: "{{fe_awaited}} == true"
+    action: set
+    vars: { fe_state: "not gated here — you do not work on it, and its own developer gates it" }
+  - id: fe_state_gated
+    condition: "{{fe_gated}} == true"
+    action: set
+    vars: { fe_state: "gated — tests green={{fe_test_ok}} (tool `{{fe_test_tool}}`, actually ran={{fe_test_ran}}), requirements met={{fe_req_vote}}, recorded `{{fe_verdict}}` in .aw-slice-gate.frontend.json" }
+
   # THE REPORT IS ALWAYS WRITTEN — green or red. A green one is the record that this change
   # was verified built before it was merged, which is what makes the merge auditable; a red
   # one is the work list. It lands beside the change's other documents, so close-delta
-  # archives it with them.
+  # archives it with them. A developer working one lane of two writes their own,
+  # delta-slice-analyze-report.<lane>.md, so two developers gating the same change never
+  # rewrite each other's report; a developer on every lane writes
+  # delta-slice-analyze-report.md.
+  - id: report_file_set
+    action: set
+    vars: { report_file: "{{cr_dir}}/delta-slice-analyze-report.md" }
+  - id: report_file_lane
+    condition: "{{working_kind}} != "
+    action: set
+    vars: { report_file: "{{cr_dir}}/delta-slice-analyze-report.{{working_kind}}.md" }
   # An EMPTY envelope, on purpose. build_context REPLACES the payload and PERSISTS, so
   # without this the report would inherit whichever lane's documents were checked last —
   # and a report step holding the plans it is reporting on starts re-deriving findings
@@ -622,27 +893,31 @@ workflow:
   - id: write_report
     action: agent_author
     include_standards: false
-    output_target: { type: file, path: "{{cr_dir}}/delta-slice-analyze-report.md" }
+    output_target: { type: file, path: "{{report_file}}" }
     task: |
       Write a Delta Slice Analyze Report for change {{cr_id}} (wave {{wave}}) to the
       output. This gate asked whether the change's CODE does what its DELTA SPEC asked for
       — the requirements are the anchor, the delta plan was the map — before finalize-delta
       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}}. 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}}
+      Evidence — the change names the lanes `{{cr_lanes_csv}}`; this developer works on
+      `{{working_lane}}`. Each gated lane ran its own tests and was checked on its own:
+      - service lane: {{be_state}}. Matched a slice filter={{be_test_matched}},
+        slice-scoped={{be_test_scoped}}. Failing lines: {{be_test_excerpt}} · Log tail:
+        {{be_test_log}} · gaps: {{be_gaps}}
+      - experience lane: {{fe_state}}. Matched a slice filter={{fe_test_matched}},
+        slice-scoped={{fe_test_scoped}}. Failing lines: {{fe_test_excerpt}} · Log tail:
+        {{fe_test_log}} · gaps: {{fe_gaps}}
       Markdown format:
       - "# Delta Slice Analyze Report — {{cr_id}}" plus today's date.
-      - A verdict line: "verdict: REQUIREMENTS MET ✓" when the tests are green and every
-        gated lane passed, else "verdict: NOT READY ✗ · <n> finding(s)".
-      - "## Evidence" — the test fence (tool, green or red, and the log tail when red), and
-        which lanes were gated. A lane that was NOT gated is listed as "not gated — this
-        change has no delta plan for it", never as a pass. WHERE `actually ran` IS FALSE,
-        say so in that section in plain words — the fence went green because this project's
-        lanes declare no test command, not because a suite passed — and note that the
+      - A verdict line: "verdict: REQUIREMENTS MET ✓" when every gated lane's tests are
+        green and every gated lane passed, else "verdict: NOT READY ✗ · <n> finding(s)".
+      - "## Evidence" — one entry per lane, with the lane's state as given above. For a
+        gated lane: its test fence (tool, green or red, and the log tail when red), its
+        requirement verdict, and the result recorded in its .aw-slice-gate.<lane>.json. A
+        lane that was NOT gated is listed with the reason given, never as a pass — and one
+        its own developer gates is said to be theirs, not missing. WHERE A GATED LANE'S
+        `actually ran` IS FALSE, say so in plain words — its fence went green because the
+        lane declares no test command, not because a suite passed — and note that the
         requirement findings below, not the fence, are what answer whether the change does
         what it was asked to.
       - "## Findings" as a table — | # | check | lane | severity | delta-spec ref | where |
@@ -671,9 +946,8 @@ workflow:
     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}}. {{gap_summary}}
+      Change {{cr_id}} does NOT yet meet its delta spec. Service lane: {{be_state}}.
+      Experience lane: {{fe_state}}. {{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
@@ -691,7 +965,7 @@ workflow:
       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
+      {{report_file}}. 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.
@@ -714,16 +988,26 @@ outputs:
   cr_dir: "{{cr_dir}}"
   wave: "{{wave}}"
   built: "{{gate_ok}}"
-  tests_green: "{{test_ok}}"
-  tests_ran: "{{test_ran}}"      # false + green = the project declares no test command
-  test_tool: "{{test_tool}}"
+  tests_green: "{{test_ok}}"     # every gated lane's tests
+  working_lane: "{{working_lane}}"
+  change_lanes: "{{cr_lanes_csv}}"
   backend_gated: "{{be_gated}}"
+  backend_state: "{{be_state}}"
+  backend_tests_green: "{{be_test_ok}}"
+  backend_tests_ran: "{{be_test_ran}}"   # false + green = the lane declares no test command
+  backend_test_tool: "{{be_test_tool}}"
   backend_ok: "{{be_ok}}"
   backend_gaps: "{{be_gaps}}"
+  backend_verdict: "{{be_verdict}}"      # as recorded in .aw-slice-gate.backend.json
   frontend_gated: "{{fe_gated}}"
+  frontend_state: "{{fe_state}}"
+  frontend_tests_green: "{{fe_test_ok}}"
+  frontend_tests_ran: "{{fe_test_ran}}"
+  frontend_test_tool: "{{fe_test_tool}}"
   frontend_ok: "{{fe_ok}}"
   frontend_gaps: "{{fe_gaps}}"
-  report: "{{cr_dir}}/delta-slice-analyze-report.md"
+  frontend_verdict: "{{fe_verdict}}"     # as recorded in .aw-slice-gate.frontend.json
+  report: "{{report_file}}"                # delta-slice-analyze-report.<lane>.md when one lane of two is worked
   source_count: "{{source_count}}"
-  note: "Gated change {{cr_id}} (wave {{wave}}) — delta-spec.md is the ANCHOR, so the question answered here is whether the CODE does what the change asked for, not whether it matches the plan. The delta plan is the MAP from a requirement to the element that serves it, and is cross-checked in its own right; the change's model delta supplies the invariants the code must enforce, and they are requirements too. The masters are read-only context for what was already there — they do not carry this change until finalize-delta merges it. Only a lane with a delta plan for THIS change is gated: backend {{be_gated}}, frontend {{fe_gated}} — an ungated lane is reported as not gated, never as a pass. The tests ran here for the first time on the change path, since build only compiles. This gate verifies: it generated no code and repaired nothing, and every finding names the command that closes it."
+  note: "Gated change {{cr_id}} (wave {{wave}}) — delta-spec.md is the ANCHOR, so the question answered here is whether the CODE does what the change asked for, not whether it matches the plan. The delta plan is the MAP from a requirement to the element that serves it, and is cross-checked in its own right; the change's model delta supplies the invariants the code must enforce, and they are requirements too. The masters are read-only context for what was already there — they do not carry this change until finalize-delta merges it. Only a lane the change names, that you work on and that has a delta plan for THIS change is gated: backend — {{be_state}}; frontend — {{fe_state}}. An ungated lane is reported as not gated, never as a pass, and a lane somebody else works on is gated in their own run. Each gated lane ran its own tests, here for the first time on the change path since build only compiles, and its pass or fail is recorded in {{cr_dir}}/.aw-slice-gate.<lane>.json. This gate verifies: it generated no code and repaired nothing, and every finding names the command that closes it."
   next: "/appweaver finalize-delta → analyze-slice → close-delta. The change MEETS ITS SPEC and is still OPEN: finalize-delta merges it into spec.md + the context's domain-model.md — writing requirements the code has now been shown to satisfy — analyze-slice then scores the WHOLE slice against those merged masters (behaviour, domain conformance and the referrer blast radius) while a red result is still recoverable, and close-delta LAST archives the change and bumps the version."