aw-spec-cli 0.1.28 → 0.1.30

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

@@ -13,9 +13,10 @@
 #
 # SELF-DETECTING, off the CHANGES ON DISK (symmetric with how `plan` keys off the plan
 # documents' own existence):
-#   • BOOTSTRAP (no change open) → generate from the MASTER plans.
+#   • BOOTSTRAP (no open change names a working lane) → generate from the MASTER plans.
 #     Next: /appweaver build → analyze-slice.
-#   • DELTA (one or more changes/<CR-id>/ open) → ASK WHICH ONE, activate it, and
+#   • DELTA (one or more changes/<CR-id>/ open that name a working lane on their
+#     **Lanes** line) → ASK WHICH ONE, activate it, and
 #     generate ONLY what that change's delta plans mark ADDED / MODIFIED, into the
 #     tree that is already there. The masters are the BASE, read and never written.
 #     A bare CR id in the argument selects without a prompt; a feature with exactly one
@@ -34,15 +35,34 @@
 # goes unbuilt; failing silently is how a frontend that was never generated reports green.
 # Only when NO lane can run does the phase stop, naming every reason it collected.
 #
+# IT GENERATES THE DEVELOPER'S WORKING LANE. .appweaver/lane.json (select-stack writes the
+# default, select-lane narrows it, not committed) names the lanes this developer works on.
+# Only a working lane is offered, gated, generated and reported on; a declared lane that is
+# somebody else's is neither asked about nor warned about, and the other developer builds
+# it in a run of their own. With the default (every declared lane) nothing changes.
+#
+# A CHANGE TAKES OVER ONLY THE LANES IT NAMES. Each change's delta-spec carries a **Lanes**
+# line. Only the changes naming a working lane are listed (cr-list --lane), so a frontend
+# developer is not pulled into change mode by a backend-only change: their lane is still
+# built from its master plan, and the change is named in a note. On the delta path a
+# working lane the chosen change does not name is skipped with that reason — for a
+# developer on `both`, a backend-only change builds the backend only, and the frontend's
+# master is built by working that lane alone (select-lane frontend) while the change is
+# open. A change with no **Lanes** line names every lane.
+#
 # IT ASKS BEFORE IT WRITES. Generation is the expensive, side-effecting step of the
 # pipeline, so each runnable lane confirms first, naming its stack, its plan and the
 # subtree it will write into. Answering no to one lane leaves the other free to run.
 #
-# THE FRONTEND BINDS TO THE SERVICE AS BUILT. Between the two lanes, the service's API
-# document is exported from the running code, the frontend's client is generated from it,
-# and the operation ids the frontend plan cites are checked against it; the frontend then
-# generates with the document in context. Each of those steps warns rather than stops —
-# see the API CONTRACT block before the lane swap.
+# THE BACKEND PUBLISHES THE API DOCUMENT, THE FRONTEND READS IT. When the service lane
+# generates, its API document is exported from the running code and saved beside it, to be
+# committed. When the frontend lane generates, it never starts the service: it reads that
+# committed document plus the operations the backend plan has drafted and the service does
+# not serve yet (api-draft.json), combined into one, generates its client from it and
+# checks the operation ids its plan cites against it. Contract requests the backend plan has
+# not answered are named, and the bindings that wait on them are left unbound while the
+# rest of the lane generates. Every one of those steps warns rather than stops — see the
+# API CONTRACT block before the lane swap.
 #
 # THE PLAN SAYS WHAT TO BUILD, THE MODEL SAYS WHAT THE DOMAIN IS. This phase does NOT read
 # spec.md — analyze-plan already conformed the plans to it, so the plan is the complete,
@@ -52,11 +72,12 @@
 # AND THAT SENTENCE IS NOW CHECKED. "analyze-plan already conformed them" was an assumption
 # about the order the operator ran things in: the lane gates test that the plan FILE EXISTS
 # and nothing more, so `plan` → edit spec.md → `implement` generated at full length from a
-# plan nobody had held against the spec it now contradicts. analyze-plan leaves a receipt of
-# the bytes it checked and its verdict, and plan-gate-check reads it here, on the bootstrap
-# path, before any lane generates. A feature with no receipt has simply never been gated
-# since the receipt existed — reported, never refused. One whose receipt no longer matches,
-# or whose verdict left plan gaps, stops; one whose verdict left only spec/model gaps warns.
+# plan nobody had held against the spec it now contradicts. analyze-plan leaves a receipt PER
+# LANE of the bytes it checked and that lane's verdict, and plan-gate-check reads each working
+# lane's here, on the bootstrap path, before any lane generates. A lane with no receipt has
+# simply never been gated since the receipt existed — reported, never refused. One whose
+# receipt no longer matches, or whose verdict left plan gaps, is skipped with the reason while
+# the other lane still runs; one whose verdict left only spec/model gaps warns.
 # 3.2.0 — AND NOT delta-spec.md EITHER. The change path used to inline it "only so the
 # paired tests can cite traceability ids", which made the rule true on the bootstrap path
 # and false on the one where changes actually ship: a document in the payload is a document
@@ -133,8 +154,8 @@
 # =============================================================================
 
 name: aw-spec-implement
-description: "Generate the aggregate's source files and paired tests from its lane plans — the backend lane from backend-plan.md when a backend stack is declared, the frontend lane from frontend-plan.md when a frontend stack is, both when both are. One command covers backend-only, frontend-only and full-stack projects and absorbs the former implement-ui and implement-delta. Self-detecting off the changes on disk — with none open it generates from the master plans; with one or more open it ASKS which change and generates only what that change's delta plans mark ADDED or MODIFIED, leaving the masters untouched. Every lane is gated on its own lane root folder, its own plan and its own scaffolded project, and a lane missing any of them is reported and skipped rather than failing the other lane; each runnable lane confirms before it writes. Model-driven, and it does not read the spec — analyze-plan already conformed the plans to it. The plan says WHAT to build; the bounded context's domain-model.md, in context alongside it, says what the domain IS — the entity names, the boundary and the text of every invariant the plan cites by id — joined on the delta path by that change's own model delta, since the master is not merged until finalize-delta. The stack binds here from the lane declaration and the constitution halves; the plans stay technology-agnostic."
-version: 3.10.0
+description: "Generate the aggregate's source files and paired tests from its lane plans — the backend lane from backend-plan.md when a backend stack is declared, the frontend lane from frontend-plan.md when a frontend stack is, both when both are. One command covers backend-only, frontend-only and full-stack projects and absorbs the former implement-ui and implement-delta. Self-detecting off the changes on disk — with none open that names a lane you work on (its **Lanes** line) it generates from the master plans; with one or more it ASKS which change and generates only what that change's delta plans mark ADDED or MODIFIED, for the lanes the change names, leaving the masters untouched. Every lane is gated on its own lane root folder, its own plan and its own scaffolded project, and a lane missing any of them is reported and skipped rather than failing the other lane; each runnable lane confirms before it writes. Model-driven, and it does not read the spec — analyze-plan already conformed the plans to it. The plan says WHAT to build; the bounded context's domain-model.md, in context alongside it, says what the domain IS — the entity names, the boundary and the text of every invariant the plan cites by id — joined on the delta path by that change's own model delta, since the master is not merged until finalize-delta. The stack binds here from the lane declaration and the constitution halves; the plans stay technology-agnostic."
+version: 3.13.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -184,20 +205,49 @@ vars:
   # verdict, and has anything moved since. analyze-plan writes it on every master run; this
   # phase is the reader. Bootstrap path only: a delta generates from delta plans, which
   # analyze-plan-delta gates, and the master receipt says nothing about those.
-  gate_tracked: "false"
-  gate_fresh: "false"
-  gate_reason: ""
-  gate_at: ""
-  gate_verdict: ""          # conformant | routed-gaps | gaps — empty with no receipt
-  gate_routed_csv: ""       # the gaps only /appweaver specify can close
-  gate_may_generate: "true"
-  gate_no_routed: "true"    # lowered when the receipt's verdict is routed-gaps — a warning, not a stop
-  # DEFAULTED PERMISSIVE, DELIBERATELY, and it is the one flag here that is. Every tree that
-  # predates the receipt has none, and "never gated" is an unknown, not a stale plan —
-  # refusing on a missing file would block every existing feature on its first run. The flag
-  # is lowered only by a receipt that EXISTS and refuses: the bytes moved since it was
+  # ONE RECEIPT PER LANE (.aw-plan-gate.<lane>.json, or the shared .aw-plan-gate.json of a
+  # feature gated before the per-lane receipts, narrowed to that lane's plan), so a lane is
+  # refused only for its own plan and its own verdict.
+  be_gate_check: "false"
+  be_gate_tracked: "false"
+  be_gate_fresh: "false"
+  be_gate_reason: ""
+  be_gate_at: ""
+  be_gate_verdict: ""       # conformant | routed-gaps | gaps — empty with no receipt
+  be_gate_routed_csv: ""    # the gaps only /appweaver specify can close
+  be_gate_may_generate: "true"
+  be_gate_no_routed: "true" # lowered when the receipt's verdict is routed-gaps — a warning, not a stop
+  fe_gate_check: "false"
+  fe_gate_tracked: "false"
+  fe_gate_fresh: "false"
+  fe_gate_reason: ""
+  fe_gate_at: ""
+  fe_gate_verdict: ""
+  fe_gate_routed_csv: ""
+  fe_gate_may_generate: "true"
+  fe_gate_no_routed: "true"
+  # DEFAULTED PERMISSIVE, DELIBERATELY, and they are the only flags here that are. Every
+  # tree that predates the receipt has none, and "never gated" is an unknown, not a stale
+  # plan — refusing on a missing file would block every existing feature on its first run.
+  # Each is lowered only by a receipt that EXISTS and refuses: the bytes moved since it was
   # written, or its verdict left gaps a plan rewrite closes.
-  may_generate: "true"
+  be_may_generate: "true"
+  fe_may_generate: "true"
+  # THE WORKING LANES (.appweaver/lane.json).
+  be_working: "false"
+  fe_working: "false"
+  working_lane: ""
+  # THE CHANGE'S LANES. cr-list lists only the changes naming a working lane; the chosen
+  # change's **Lanes** line then decides which working lanes this delta run builds.
+  impl_hidden_csv: ""          # open changes left out: they name only a lane not worked here
+  impl_preselect_hidden: ""    # the argument named one of those
+  preselect_visible: "true"
+  no_hidden: "true"
+  cr_lanes_csv: ""
+  be_in_change: "true"         # every lane until cr-paths answers (and always on the bootstrap path)
+  fe_in_change: "true"
+  be_report: "false"           # worked AND in this run's target ⇒ its gaps are reported below
+  fe_report: "false"
   # PER-LANE STATE. Each lane resolves its own plan, its own project and its own answer;
   # a lane that is not declared never resolves any of them and its steps never run.
   # The engine has no compound conditions, so each AND is an ordered assignment: a step
@@ -254,18 +304,34 @@ vars:
   fe_gap_names: ""
   fe_gaps_text: "none"
   # THE API CONTRACT between the lanes — see the block before the lane swap. Every flag
-  # starts lowered, so a run without a frontend lane never touches any of it.
-  contract_go: "false"
+  # starts lowered: the backend half publishes only when the service lane generates, and
+  # the frontend half reads only when the frontend lane does.
+  contract_go: "false"         # PUBLISH — the service lane generated in this run
   contract_ok: ""
-  contract_doc: ""
-  contract_doc_exists: "false"
+  export_doc: ""               # the service's exported document (contracts/openapi.json)
+  export_doc_exists: "false"
   contract_reason: ""
   contract_already: "false"
   contract_fresh: "true"
   contract_log: ""
   contract_placeholder: ""
   contract_export_status: ""
-  contract_status: "not exported — no API document is in context, so take each binding from the plan alone and say so in your summary"
+  combine_go: "false"          # READ — the frontend lane generates and a service lane is declared
+  combined_ok: ""
+  combined_status: ""
+  combined_reason: ""
+  combined_export: ""
+  combined_clashes: ""
+  clashes_clear: "true"
+  contract_doc: ""             # what the frontend binds to: the combined document
+  contract_doc_exists: "false"
+  contract_status: "none — no API document is in context, so take each binding from the plan alone and say so in your summary"
+  req_open_csv: ""             # the frontend plan's contract requests the backend plan has not answered
+  req_backend_text: "none"
+  req_summary: ""
+  req_clear: "true"
+  check_drafted: ""
+  drafted_clear: "true"
   client_go: "false"
   client_ask: "false"
   client_answer: ""
@@ -346,6 +412,9 @@ workflow:
       - { name: fe_reserved,    from: "$.frontend_reserved_csv" }
       - { name: fe_workdir,     from: "$.frontend_workdir" }
       - { name: fe_client,      from: "$.frontend_client" }
+      - { name: be_working,     from: "$.backend_working" }
+      - { name: fe_working,     from: "$.frontend_working" }
+      - { name: working_lane,   from: "$.working_lane" }
 
   - id: require_lanes
     action: verify_context
@@ -409,20 +478,46 @@ workflow:
       - { name: owned_sections, from: "$.owned_sections" }
 
   # 2. WHICH CHANGES ARE OPEN — the evidence is changes/<CR-id>/ on disk; a closed change
-  #    has moved to changes/archive/. Any open change makes this run a DELTA run.
-  #    `matched_label` resolves a CR id passed as the argument to the whole option string,
-  #    so the pick below can auto-select it (the engine matches a preselection against the
-  #    option text exactly).
+  #    has moved to changes/archive/. An open change that names a working lane on its
+  #    **Lanes** line makes this run a DELTA run; one naming only a lane this developer
+  #    does not work on is left out (`--lane`, last in the args so an empty value cannot be
+  #    mistaken for the next flag) and named in a note. `matched_label` resolves a CR id
+  #    passed as the 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: impl_hidden_csv,       from: "$.hidden_ids_csv" }
+      - { name: impl_preselect_hidden, from: "$.preselect_hidden" }
+
+  # `implement CR-…` naming a change for another lane only stops, rather than building
+  # something the argument did not ask for.
+  - id: preselect_hidden_flag
+    condition: "{{impl_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 {{impl_preselect_hidden}} does not touch your working lane `{{working_lane}}` (.appweaver/lane.json): its **Lanes** line names only the other lane, so there is nothing for you to build for it. Run /appweaver select-lane to work on that lane — or, if the change does need your lane, widen it with `.appweaver/scripts/bash/aw-spec-actions.sh cr-lanes --cr-id {{impl_preselect_hidden}} --set both` and plan your half with /appweaver plan {{impl_preselect_hidden}}."
+
+  - id: hidden_flag
+    condition: "{{impl_hidden_csv}} != "
+    action: set
+    vars: { no_hidden: "false" }
+  - id: note_hidden
+    action: verify_context
+    require_true: no_hidden
+    on_false: continue
+    on_false_message: "NOTE — open change(s) for a lane you do not work on, left to that lane's developer and not built here: {{impl_hidden_csv}}. They do not put your lane into change mode."
 
   - id: mode_delta
     condition: "{{has_changes}} == true"
@@ -480,6 +575,11 @@ workflow:
       - { name: delta_frontend_plan,       from: "$.delta_frontend_plan" }
       - { name: delta_frontend_plan_exists, from: "$.delta_frontend_plan_exists" }
       - { name: wave,                      from: "$.wave" }
+      # The lanes the change names — its delta-spec's **Lanes** line, every lane when it
+      # records none.
+      - { name: cr_lanes_csv,              from: "$.lanes_csv" }
+      - { name: be_in_change,              from: "$.touches_backend" }
+      - { name: fe_in_change,              from: "$.touches_frontend" }
 
   # 3. WHICH PLAN EACH LANE GENERATES FROM, resolved once per lane from the mode — the
   #    master on the bootstrap path, this change's delta plan on the delta path. Every gate
@@ -508,61 +608,93 @@ workflow:
   #     spec.md, `implement` therefore generated from a plan that was never held against the
   #     spec it now contradicts, silently and at full length.
   #
-  #     plan-gate-check compares today's bytes against the receipt analyze-plan left — spec.md,
-  #     the context's domain-model.md and each gated lane plan — and reads the verdict that
-  #     run reached. The plans' own `**Version**:` headers cannot answer this and must not be
-  #     used: close-delta stamps them and spec.md to the same number in lockstep whether or not
-  #     a plan was re-derived, so the comparison reads equal always.
+  #     plan-gate-check compares today's bytes against the receipt analyze-plan left for the
+  #     lane — spec.md, the context's domain-model.md and that lane's plan — and reads the
+  #     verdict that run reached for it. The plans' own `**Version**:` headers cannot answer
+  #     this and must not be used: close-delta stamps them and spec.md to the same number in
+  #     lockstep whether or not a plan was re-derived, so the comparison reads equal always.
   #
-  #     THREE OUTCOMES FOR A RECEIPT. Moved bytes refuse. Verdict `gaps` refuses: that run left
-  #     gaps a plan rewrite closes. Verdict `routed-gaps` generates and warns: what is left
-  #     can only be closed in the spec or the model, and it is listed for /appweaver specify.
+  #     THREE OUTCOMES FOR A RECEIPT. Moved bytes refuse the lane. Verdict `gaps` refuses it:
+  #     that run left gaps a plan rewrite closes. Verdict `routed-gaps` generates and warns:
+  #     what is left can only be closed in the spec or the model, and it is listed for
+  #     /appweaver specify. A refused lane is SKIPPED with the reason, like every other lane
+  #     gap below — the other lane, whose own receipt is clean, still runs.
   #
-  #     BOOTSTRAP ONLY. A delta run generates from delta plans that analyze-plan-delta gates;
-  #     the master receipt is silent about them, and reading it there would refuse a change
-  #     for drift in documents this run is not building from.
-  - id: plan_gate_check
+  #     PER WORKING LANE, BOOTSTRAP ONLY. A delta run generates from delta plans that
+  #     analyze-plan-delta gates; the master receipt is silent about them, and reading it
+  #     there would refuse a change for drift in documents this run is not building from.
+  - id: be_gate_arm
     condition: "{{mode}} == bootstrap"
+    action: set
+    vars: { be_gate_check: "{{be_working}}" }
+  - id: fe_gate_arm
+    condition: "{{mode}} == bootstrap"
+    action: set
+    vars: { fe_gate_check: "{{fe_working}}" }
+
+  - id: plan_gate_check_backend
+    condition: "{{be_gate_check}} == true"
     action: execute_script
     script: { ref: actions }
     subcommand: plan-gate-check
-    args: ["--feature-dir", "{{feature_dir}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--lane", "backend"]
+    outputs:
+      - { name: be_gate_tracked,      from: "$.tracked" }
+      - { name: be_gate_fresh,        from: "$.gate_fresh" }
+      - { name: be_gate_verdict,      from: "$.verdict" }
+      - { name: be_gate_may_generate, from: "$.may_generate" }
+      - { name: be_gate_routed_csv,   from: "$.routed_csv" }
+      - { name: be_gate_reason,       from: "$.reason" }
+      - { name: be_gate_at,           from: "$.gated" }
+  - id: plan_gate_check_frontend
+    condition: "{{fe_gate_check}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-gate-check
+    args: ["--feature-dir", "{{feature_dir}}", "--lane", "frontend"]
     outputs:
-      - { name: gate_tracked,      from: "$.tracked" }
-      - { name: gate_fresh,        from: "$.gate_fresh" }
-      - { name: gate_verdict,      from: "$.verdict" }
-      - { name: gate_may_generate, from: "$.may_generate" }
-      - { name: gate_routed_csv,   from: "$.routed_csv" }
-      - { name: gate_reason,       from: "$.reason" }
-      - { name: gate_at,           from: "$.gated" }
+      - { name: fe_gate_tracked,      from: "$.tracked" }
+      - { name: fe_gate_fresh,        from: "$.gate_fresh" }
+      - { name: fe_gate_verdict,      from: "$.verdict" }
+      - { name: fe_gate_may_generate, from: "$.may_generate" }
+      - { name: fe_gate_routed_csv,   from: "$.routed_csv" }
+      - { name: fe_gate_reason,       from: "$.reason" }
+      - { name: fe_gate_at,           from: "$.gated" }
 
-  #     The ordered assignment is the AND: only a TRACKED feature can lower the flag, and
-  #     what lowers it is plan-gate-check's may_generate. An untracked one never reaches
-  #     this step's assignment and generates, which is the whole accommodation for trees
-  #     that have not been gated since the receipt existed.
-  - id: flag_gate_block
-    condition: "{{gate_tracked}} == true"
+  #     The ordered assignment is the AND: only a TRACKED lane can lower its flag, and what
+  #     lowers it is plan-gate-check's may_generate. An untracked lane never reaches this
+  #     step's assignment and generates, which is the whole accommodation for trees that
+  #     have not been gated since the receipt existed.
+  - id: be_flag_gate_block
+    condition: "{{be_gate_tracked}} == true"
     action: set
-    vars: { may_generate: "{{gate_may_generate}}" }
-
-  - id: require_gate_fresh
-    action: verify_context
-    require_true: may_generate
-    on_false: stop
-    on_false_message: "implement REFUSED — analyze-plan's receipt does not clear these plans: {{gate_reason}}. This phase generates from the plans and does NOT read the spec, on the strength of that gate having checked them against it, so generating now would realise a plan against requirements nobody held it to. Re-run /appweaver analyze-plan — it re-checks all four checks, repairs the drifting plan on approval, and re-issues the receipt — then re-run /appweaver implement. If what changed was a plan you re-derived with /appweaver plan main, that is the same path: the re-derived plans have not been gated yet. Nothing was generated."
-
-  #     THE WARNING for a receipt whose only open gaps belong to specify. Generation goes on:
-  #     no plan rewrite could close them, and the plan is what this phase builds from.
-  - id: flag_routed_gaps
-    condition: "{{gate_verdict}} == routed-gaps"
+    vars: { be_may_generate: "{{be_gate_may_generate}}" }
+  - id: fe_flag_gate_block
+    condition: "{{fe_gate_tracked}} == true"
     action: set
-    vars: { gate_no_routed: "false" }
+    vars: { fe_may_generate: "{{fe_gate_may_generate}}" }
 
-  - id: warn_routed_gaps
+  #     THE WARNING for a receipt whose only open gaps belong to specify. That lane still
+  #     generates: no plan rewrite could close them, and the plan is what this phase builds
+  #     from.
+  - id: be_flag_routed_gaps
+    condition: "{{be_gate_verdict}} == routed-gaps"
+    action: set
+    vars: { be_gate_no_routed: "false" }
+  - id: fe_flag_routed_gaps
+    condition: "{{fe_gate_verdict}} == routed-gaps"
+    action: set
+    vars: { fe_gate_no_routed: "false" }
+  - id: warn_be_routed_gaps
     action: verify_context
-    require_true: gate_no_routed
+    require_true: be_gate_no_routed
     on_false: continue
-    on_false_message: "WARNING — analyze-plan left gaps only the spec or the model can close, so the code generated now will not cover them: {{gate_routed_csv}}. Lift each into spec.md / domain-model.md by opening a change with /appweaver specify."
+    on_false_message: "WARNING — analyze-plan left backend gaps only the spec or the model can close, so the backend code generated now will not cover them: {{be_gate_routed_csv}}. Lift each into spec.md / domain-model.md by opening a change with /appweaver specify."
+  - id: warn_fe_routed_gaps
+    action: verify_context
+    require_true: fe_gate_no_routed
+    on_false: continue
+    on_false_message: "WARNING — analyze-plan left frontend gaps only the spec or the model can close, so the frontend code generated now will not cover them: {{fe_gate_routed_csv}}. Lift each into spec.md / domain-model.md by opening a change with /appweaver specify."
 
   # 4. THE PROJECT each declared lane generates INTO. Deterministic structure gate:
   #    detect-project searches the LANE'S OWN subtree for an ecosystem manifest (.sln/
@@ -600,55 +732,94 @@ workflow:
     action: set
     vars: { fe_project_ok: "true" }
 
-  # 5. REPORT EACH DECLARED LANE'S GAPS AND CARRY ON. `on_false: continue` is the whole
+  # 5. REPORT EACH WORKING LANE'S GAPS AND CARRY ON. `on_false: continue` is the whole
   #    point: the message is the deliverable, not the stop. A lane that cannot run is named
   #    here with the command that fixes it, and the run continues so the other lane still
-  #    generates. If NOTHING can run, the gate at step 7 stops with that fact.
+  #    generates. If NOTHING can run, the gate at step 7 stops with that fact. A declared
+  #    lane this developer does not work on is not reported: it is somebody else's.
+  #
+  #    A WORKING LANE THE CHANGE DOES NOT NAME is skipped with that one reason, and none of
+  #    the gaps below is reported for it: it has no delta plan by design, and "run plan" is
+  #    not the fix. be_report / fe_report = worked AND in this run's target.
+  - id: be_report_raise
+    condition: "{{be_in_change}} == true"
+    action: set
+    vars: { be_report: "{{be_working}}" }
+  - id: fe_report_raise
+    condition: "{{fe_in_change}} == true"
+    action: set
+    vars: { fe_report: "{{fe_working}}" }
+  - id: note_be_not_in_change
+    condition: "{{be_working}} == true"
+    action: verify_context
+    require_true: be_in_change
+    on_false: continue
+    on_false_message: "BACKEND LANE NOT IN THIS CHANGE — change {{cr_id}} names only {{cr_lanes_csv}} on its **Lanes** line, so the backend has nothing to build for it and is skipped. To build the backend from its master plan while this change is open, work that lane alone (/appweaver select-lane backend) and re-run implement: a change that does not name a lane leaves it on its master plan."
+  - id: note_fe_not_in_change
+    condition: "{{fe_working}} == true"
+    action: verify_context
+    require_true: fe_in_change
+    on_false: continue
+    on_false_message: "FRONTEND LANE NOT IN THIS CHANGE — change {{cr_id}} names only {{cr_lanes_csv}} on its **Lanes** line, so the frontend has nothing to build for it and is skipped. To build the frontend from its master plan while this change is open, work that lane alone (/appweaver select-lane frontend) and re-run implement: a change that does not name a lane leaves it on its master plan."
+
+  - id: warn_be_gate
+    condition: "{{be_report}} == true"
+    action: verify_context
+    require_true: be_may_generate
+    on_false: continue
+    on_false_message: "BACKEND LANE SKIPPED — analyze-plan's receipt does not clear the backend plan: {{be_gate_reason}}. This phase generates from the plan and does NOT read the spec, on the strength of that gate having checked it, so generating now would realise a plan against requirements nobody held it to. Re-run /appweaver analyze-plan — it re-checks the plan, repairs it on approval and re-issues the backend receipt — then re-run /appweaver implement. If what changed was a plan you re-derived with /appweaver plan main, that is the same path. Nothing is generated for this lane; any other working lane still runs."
+  - id: warn_fe_gate
+    condition: "{{fe_report}} == true"
+    action: verify_context
+    require_true: fe_may_generate
+    on_false: continue
+    on_false_message: "FRONTEND LANE SKIPPED — analyze-plan's receipt does not clear the frontend plan: {{fe_gate_reason}}. This phase generates from the plan and does NOT read the spec, on the strength of that gate having checked it, so generating now would realise a plan against requirements nobody held it to. Re-run /appweaver analyze-plan — it re-checks the plan, repairs it on approval and re-issues the frontend receipt — then re-run /appweaver implement. Nothing is generated for this lane; any other working lane still runs."
   - id: warn_be_plan
-    condition: "{{be_declared}} == true"
+    condition: "{{be_report}} == true"
     action: verify_context
     require_true: be_plan_ok
     on_false: continue
     on_false_message: "BACKEND LANE SKIPPED — lane `{{be_lane_id}}` ({{be_title}}) is declared in .appweaver/stacks.json, but the plan this run generates from is not there: {{be_plan}}. Run /appweaver plan (then /appweaver analyze-plan for the masters, or /appweaver analyze-plan-delta for a change) and re-run implement. Nothing is generated for this lane; any other declared lane still runs."
   - id: warn_be_root
-    condition: "{{be_declared}} == true"
+    condition: "{{be_report}} == true"
     action: verify_context
     require_true: be_root_exists
     on_false: continue
     on_false_message: "BACKEND LANE SKIPPED — lane `{{be_lane_id}}` ({{be_title}}) declares lane root folder `{{be_source_path}}` in .appweaver/stacks.json, and that path is not a directory in this repository. A lane owns its subtree and this phase writes into it, so there is nothing to generate into: scaffold a project there with /appweaver foundation (a pack or a spec for {{be_profile}}, or a spec you give it), create one with the stack's own tooling, or re-run /appweaver select-stack and point the lane at the directory that really holds its source. Nothing is generated for this lane; any other declared lane still runs."
   - id: warn_be_project
-    condition: "{{be_declared}} == true"
+    condition: "{{be_report}} == true"
     action: verify_context
     require_true: be_project_ok
     on_false: continue
     on_false_message: "BACKEND LANE SKIPPED — no project found under the {{be_lane_id}} lane root folder `{{be_source_path}}`, nor anywhere else in this repository. This phase GENERATES into an existing project tree, so one has to be scaffolded first: run /appweaver foundation, which scaffolds it from a pack or from a spec (one it ships for {{be_profile}}, or one you give it), or create the project with the stack's own tooling under that path. Any ecosystem manifest marks it — .sln/.csproj, pom.xml, build.gradle(.kts), package.json, go.mod, Cargo.toml or pyproject.toml."
   - id: warn_fe_plan
-    condition: "{{fe_declared}} == true"
+    condition: "{{fe_report}} == true"
     action: verify_context
     require_true: fe_plan_ok
     on_false: continue
     on_false_message: "FRONTEND LANE SKIPPED — lane `{{fe_lane_id}}` ({{fe_title}}) is declared in .appweaver/stacks.json, but the plan this run generates from is not there: {{fe_plan}}. Run /appweaver plan (then /appweaver analyze-plan for the masters, or /appweaver analyze-plan-delta for a change) and re-run implement. Nothing is generated for this lane; any other declared lane still runs."
   - id: warn_fe_root
-    condition: "{{fe_declared}} == true"
+    condition: "{{fe_report}} == true"
     action: verify_context
     require_true: fe_root_exists
     on_false: continue
     on_false_message: "FRONTEND LANE SKIPPED — lane `{{fe_lane_id}}` ({{fe_title}}) declares lane root folder `{{fe_source_path}}` in .appweaver/stacks.json, and that path is not a directory in this repository. A lane owns its subtree and this phase writes into it, so there is nothing to generate into: scaffold a project there with /appweaver foundation (a pack or a spec for {{fe_profile}}, or a spec you give it), create one with the stack's own tooling, or re-run /appweaver select-stack and point the lane at the directory that really holds its source. Nothing is generated for this lane; any other declared lane still runs."
   - id: warn_fe_project
-    condition: "{{fe_declared}} == true"
+    condition: "{{fe_report}} == true"
     action: verify_context
     require_true: fe_project_ok
     on_false: continue
     on_false_message: "FRONTEND LANE SKIPPED — no frontend project found under the {{fe_lane_id}} lane root folder `{{fe_source_path}}`. detect-project searched that subtree and then the whole repository, and answered at scope `{{fe_project_scope}}`; `lane` is the only scope this lane accepts. Scaffold a project there — /appweaver foundation, from a pack or a spec for {{fe_profile}} or a spec you give it, or the stack's own tooling — and re-run implement. A manifest found elsewhere in the repository does NOT count: that one belongs to another lane, and generating this lane's code against it is how a frontend that was never built reports green."
 
-  # 6. RUNNABLE = declared AND its lane root folder is on disk AND its plan is there AND its
-  #    project is there, as one ordered assignment plus a knockdown per condition, since
+  # 6. RUNNABLE = worked AND its lane root folder is on disk AND its plan is there AND its
+  #    project is there AND its receipt clears it AND the chosen change names it (always, on
+  #    the bootstrap path), as one ordered assignment plus a knockdown per condition, since
   #    the engine has no compound conditions. An undeclared lane stays false either way —
   #    its `declared` value is what the raise assigns.
   - id: be_runnable_raise
     condition: "{{be_plan_ok}} == true"
     action: set
-    vars: { be_runnable: "{{be_declared}}" }
+    vars: { be_runnable: "{{be_working}}" }
   - id: be_runnable_clear_root
     condition: "{{be_root_exists}} == false"
     action: set
@@ -657,10 +828,18 @@ workflow:
     condition: "{{be_project_ok}} == false"
     action: set
     vars: { be_runnable: "false" }
+  - id: be_runnable_clear_gate
+    condition: "{{be_may_generate}} == false"
+    action: set
+    vars: { be_runnable: "false" }
+  - id: be_runnable_clear_change
+    condition: "{{be_in_change}} == false"
+    action: set
+    vars: { be_runnable: "false" }
   - id: fe_runnable_raise
     condition: "{{fe_plan_ok}} == true"
     action: set
-    vars: { fe_runnable: "{{fe_declared}}" }
+    vars: { fe_runnable: "{{fe_working}}" }
   - id: fe_runnable_clear_root
     condition: "{{fe_root_exists}} == false"
     action: set
@@ -669,6 +848,14 @@ workflow:
     condition: "{{fe_project_ok}} == false"
     action: set
     vars: { fe_runnable: "false" }
+  - id: fe_runnable_clear_gate
+    condition: "{{fe_may_generate}} == false"
+    action: set
+    vars: { fe_runnable: "false" }
+  - id: fe_runnable_clear_change
+    condition: "{{fe_in_change}} == false"
+    action: set
+    vars: { fe_runnable: "false" }
 
   # 7. CONFIRM EACH RUNNABLE LANE. Generation writes into the repository and costs a model
   #    pass per lane, so the operator says which lanes this run is for, with the stack, the
@@ -705,7 +892,7 @@ workflow:
     action: verify_context
     require_true: generate_any
     on_false: stop
-    on_false_message: "Nothing to implement — no declared lane is both ready and confirmed. Either every declared lane was skipped for a reason printed above (its lane root folder, its plan or its project is missing), or each one that was ready was declined at the prompt. Backend lane declared {{be_declared}}, ready {{be_runnable}}; frontend lane declared {{fe_declared}}, ready {{fe_runnable}}. Fix the reasons named above, or re-run and confirm a lane."
+    on_false_message: "Nothing to implement — no lane you work on (`{{working_lane}}`, .appweaver/lane.json) is both ready and confirmed. Either every working lane was skipped for a reason printed above (its lane root folder, its plan, its project, its analyze-plan receipt, or a chosen change that does not name it), or each one that was ready was declined at the prompt. Backend lane declared {{be_declared}}, worked {{be_working}}, ready {{be_runnable}}; frontend lane declared {{fe_declared}}, worked {{fe_working}}, ready {{fe_runnable}}. Fix the reasons named above, re-run and confirm a lane, or run /appweaver select-lane to work on another lane."
 
   # 8. EACH GENERATING LANE'S authoring MODE — the run's mode where the lane is going, and
   #    `skip` where it is not, which silences both of that lane's branches without a
@@ -1224,27 +1411,35 @@ workflow:
     outputs:
       - { name: okf_concept, from: "$.concept" }
 
-  # ══════════════ THE API CONTRACT — the built service, as the frontend sees it ═══
-  # The frontend binds to the service through its published API document, and the document
-  # that counts is the one the CODE serves: routes, verbs, parameters, field names and
-  # status codes as built, which the plans only describe. So before the frontend lane
-  # generates, three steps, each of which WARNS and carries on — the frontend still
-  # generates, from its plan, when one of them cannot run:
-  #   1. EXPORT — start the service with its lane's `contract_run`, save what it serves at
-  #      `contract` under its lane root folder, stop it (contract-export). The two values
-  #      come from the lane in stacks.json — where foundation records a pack's own — or
-  #      else from the stack profile.
-  #   2. CLIENT — run the frontend lane's `client` command, which generates the client from
-  #      that document. A lane with none yet asks the developer once and records the
-  #      answer on the lane; an empty answer carries on without a generated client.
-  #   3. CHECK — every operation id the frontend plan cites must be in the document
-  #      (contract-check, by script).
-  # It runs whenever the frontend lane does, including when the service was built in an
-  # earlier run, and only where a service lane is declared.
+  # ══════════════ THE API CONTRACT — published by the backend, read by the frontend ═══
+  # The frontend binds to the service through its API document, and the document that
+  # counts is the one the CODE serves: routes, verbs, parameters, field names and status
+  # codes as built, which the plans only describe. THE BACKEND PUBLISHES IT AND THE FRONTEND
+  # READS IT, so the two lanes can be built by different developers at different times.
+  # Every step below WARNS and carries on — the frontend still generates, from its plan,
+  # when one of them cannot run.
+  #   1. PUBLISH (when the service lane generated in this run) — start the service with
+  #      its lane's `contract_run`, save what it serves at `contract` under its lane root
+  #      folder, stop it (contract-export). The two values come from the lane in
+  #      stacks.json — where foundation records a pack's own — or else from the stack
+  #      profile. The document is committed with the service, and `build` refreshes it
+  #      after a green compile. A frontend run never starts the service: its developer may
+  #      have neither the service built nor its runtime installed.
+  #   2. REQUESTS — the frontend plan's contract requests the backend plan has not answered
+  #      yet (contract-requests), named to whichever lane runs.
+  #   3. COMBINE (when the frontend lane generates) — the committed document plus every
+  #      operation a backend plan has drafted (api-draft.json) and the service does not
+  #      serve yet, written to .appweaver/contracts/openapi.combined.json (contract-combine).
+  #      That is how a frontend binds to an endpoint the backend has planned and not built.
+  #   4. CLIENT — run the frontend lane's `client` command against the combined document. A
+  #      lane with none yet asks the developer once and records the answer on the lane; an
+  #      empty answer carries on without a generated client.
+  #   5. CHECK — every operation id the frontend plan cites must be in the combined
+  #      document (contract-check, by script); a cited draft operation is named apart.
   - id: contract_arm
-    condition: "{{fe_go}} == true"
+    condition: "{{be_go}} == true"
     action: set
-    vars: { contract_go: "{{be_declared}}" }
+    vars: { contract_go: "true" }
   - id: contract_export
     condition: "{{contract_go}} == true"
     action: execute_script
@@ -1253,20 +1448,19 @@ workflow:
     subcommand: contract-export
     outputs:
       - { name: contract_ok,          from: "$.ok" }
-      - { name: contract_doc,         from: "$.doc" }
-      - { name: contract_doc_exists,  from: "$.doc_exists" }
+      - { name: export_doc,           from: "$.doc" }
+      - { name: export_doc_exists,    from: "$.doc_exists" }
       - { name: contract_reason,      from: "$.reason" }
       - { name: contract_already,     from: "$.already_running" }
       - { name: contract_ops,         from: "$.operations" }
       - { name: contract_log,         from: "$.log_tail" }
-      - { name: contract_placeholder, from: "$.placeholder" }
       - { name: contract_export_status, from: "$.status" }
   - id: warn_contract_export
     condition: "{{contract_go}} == true"
     action: verify_context
     require_true: contract_ok
     on_false: continue
-    on_false_message: "API DOCUMENT NOT EXPORTED — {{contract_reason}}. The service lane `{{be_lane_id}}` is started with its `contract_run` command and its document fetched from its `contract` URL, both read from .appweaver/stacks.json or else its stack profile; correct them on the lane there if they do not fit this project, start anything the service needs, and re-run implement. Until then the frontend lane binds from its plan alone. Service output: {{contract_log}}"
+    on_false_message: "API DOCUMENT NOT EXPORTED — {{contract_reason}}. The service lane `{{be_lane_id}}` is started with its `contract_run` command and its document fetched from its `contract` URL, both read from .appweaver/stacks.json or else its stack profile; correct them on the lane there if they do not fit this project, start anything the service needs, and re-run implement or build. Until it is exported and committed, the frontend lane binds to the last committed document plus the backend plan's draft. Service output: {{contract_log}}"
   - id: contract_stale_flag
     condition: "{{contract_already}} == true"
     action: set
@@ -1277,12 +1471,78 @@ workflow:
     require_true: contract_fresh
     on_false: continue
     on_false_message: "WARNING — the API document was {{contract_reason}}. Stop that service and re-run implement to export the code as it is now."
-  - id: contract_status_set
-    condition: "{{contract_doc_exists}} == true"
+
+  # 2. THE REQUEST LEDGER — read from both plans, for whichever lane runs.
+  - id: contract_requests
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-requests
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: req_open_csv,     from: "$.open_csv" }
+      - { name: req_backend_text, from: "$.backend_text" }
+      - { name: req_summary,      from: "$.summary" }
+  - id: req_open_flag
+    condition: "{{req_open_csv}} != "
+    action: set
+    vars: { req_clear: "false" }
+  - id: warn_requests_backend
+    condition: "{{be_go}} == true"
+    action: verify_context
+    require_true: req_clear
+    on_false: continue
+    on_false_message: "FRONTEND CONTRACT REQUESTS OPEN — the frontend plan asks the service for {{req_open_csv}}, and backend-plan.md has not answered them: {{req_backend_text}}. This run generated the backend plan as it stands. Answer each request — publish it under an operation id, or decline it with the reason — with /appweaver plan or /appweaver analyze-plan for the backend lane, then re-run implement."
+  - id: warn_requests_frontend
+    condition: "{{fe_go}} == true"
+    action: verify_context
+    require_true: req_clear
+    on_false: continue
+    on_false_message: "CONTRACT REQUESTS STILL OPEN — {{req_open_csv}}: the frontend plan asks the service for these and the backend plan has not answered them. The bindings that wait on them are left unbound and marked in this run, and the rest of the frontend lane generates. The backend lane's developer answers them in backend-plan.md; re-run implement once they are published."
+
+  # 3. THE COMBINED DOCUMENT — what the frontend reads, never the running service.
+  - id: combine_arm
+    condition: "{{fe_go}} == true"
+    action: set
+    vars: { combine_go: "{{be_declared}}" }
+  - id: contract_combine
+    condition: "{{combine_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-combine
+    outputs:
+      - { name: combined_ok,          from: "$.ok" }
+      - { name: contract_doc,         from: "$.doc" }
+      - { name: combined_status,      from: "$.status" }
+      - { name: combined_reason,      from: "$.reason" }
+      - { name: combined_export,      from: "$.export" }
+      - { name: combined_clashes,     from: "$.clashes_csv" }
+      - { name: contract_placeholder, from: "$.placeholder" }
+  - id: warn_no_document
+    condition: "{{combine_go}} == true"
+    action: verify_context
+    require_true: combined_ok
+    on_false: continue
+    on_false_message: "NO API DOCUMENT — {{combined_reason}}. The backend lane publishes {{combined_export}} when its implement or build runs, and drafts its plan's endpoints into api-draft.json when plan or analyze-plan runs; once they are committed and pulled here, re-run implement. Until then the frontend lane binds from its plan alone."
+  - id: contract_doc_set
+    condition: "{{combined_ok}} == true"
     action: set
-    vars: { contract_status: "{{contract_export_status}}; it is in context" }
+    vars:
+      contract_doc_exists: "true"
+      contract_status: "{{combined_status}}; it is in context"
+  - id: clashes_flag
+    condition: "{{combined_clashes}} != "
+    action: set
+    vars: { clashes_clear: "false" }
+  - id: warn_clashes
+    condition: "{{combine_go}} == true"
+    action: verify_context
+    require_true: clashes_clear
+    on_false: continue
+    on_false_message: "DRAFT LEFT OUT — {{combined_clashes}}. The backend plan drafts an endpoint the service already serves under a different operation id, so the frontend binds to what the service serves. Correct the id in backend-plan.md (/appweaver plan or analyze-plan for the backend lane)."
 
-  # 2. THE CLIENT, generated from the document — so only once there is one.
+  # 4. THE CLIENT, generated from the combined document — so only once there is one.
   - id: client_arm
     condition: "{{contract_doc_exists}} == true"
     action: set
@@ -1326,6 +1586,7 @@ workflow:
     on_error: continue
     script: { ref: actions }
     subcommand: contract-client
+    args: ["--doc", "{{contract_doc}}"]
     outputs:
       - { name: client_ok,  from: "$.ok" }
       - { name: client_cmd, from: "$.cmd" }
@@ -1349,23 +1610,34 @@ workflow:
     on_false: continue
     on_false_message: "NO API CLIENT GENERATED — the frontend lane `{{fe_lane_id}}` has no working `client` command, so this run writes its calls from the API document {{contract_doc}} instead. Set `client` on the lane in .appweaver/stacks.json (`{{contract_placeholder}}` stands for the document) to generate the client on the next run."
 
-  # 3. THE CHECK — the operation ids the frontend plan cites, against the document.
+  # 5. THE CHECK — the operation ids the frontend plan cites, against the combined document.
   - id: contract_check
-    condition: "{{contract_doc_exists}} == true"
+    condition: "{{client_go}} == true"
     action: execute_script
     on_error: continue
     script: { ref: actions }
     subcommand: contract-check
     args: ["--plan", "{{fe_plan}}", "--doc", "{{contract_doc}}"]
     outputs:
-      - { name: check_ok,     from: "$.ok" }
-      - { name: check_reason, from: "$.reason" }
+      - { name: check_ok,      from: "$.ok" }
+      - { name: check_reason,  from: "$.reason" }
+      - { name: check_drafted, from: "$.drafted_csv" }
   - id: warn_contract_check
-    condition: "{{contract_doc_exists}} == true"
+    condition: "{{client_go}} == true"
     action: verify_context
     require_true: check_ok
     on_false: continue
-    on_false_message: "CONTRACT CHECK — {{check_reason}}. Each binding in {{fe_plan}} names the endpoint it calls by the operation id the backend plan gives it, and the built service must serve that id. Either the plan cites the wrong id (fix it with /appweaver plan, then analyze-plan) or the service never gave the endpoint that id (re-run implement for the backend lane). The frontend lane still generates; these bindings are where a call will fail."
+    on_false_message: "CONTRACT CHECK — {{check_reason}}. Each binding in {{fe_plan}} names the endpoint it calls by the operation id the backend plan gives it, or the id its contract request proposes. An id in no document belongs to a contract request the backend has not answered (open now: [{{req_open_csv}}]), or the plan cites the wrong id (fix it with /appweaver plan, then analyze-plan), or an endpoint the service never gave that id (re-run implement for the backend lane). The frontend lane still generates; these bindings are where a call will fail."
+  - id: drafted_flag
+    condition: "{{check_drafted}} != "
+    action: set
+    vars: { drafted_clear: "false" }
+  - id: warn_drafted
+    condition: "{{client_go}} == true"
+    action: verify_context
+    require_true: drafted_clear
+    on_false: continue
+    on_false_message: "BOUND TO DRAFT OPERATIONS — {{check_drafted}}: the backend plan describes these and the service does not serve them yet. The frontend binds to them through the client as to any other operation; the calls fail at run time until the backend lane implements them and publishes its API document."
 
   # ══════════════ THE LANE SWAP — the frontend's rules replace the backend's ═══
   # build_context already scoped the two lanes' PAYLOADS apart; this is the same boundary
@@ -1395,7 +1667,7 @@ workflow:
       - { path: "{{fe_plan}}" }
       - { path: "{{domain_model}}", optional: true }   # the UBIQUITOUS LANGUAGE this lane's labels, states and messages use — and what a cited BR-nnn requires
       - { path: .appweaver/memory/constitution.ui.md, optional: true }   # the lane's ratified UX-* base — conventions, forbidden patterns, gates
-      - { path: "{{contract_doc}}", optional: true }   # the service's API document as BUILT — what every §5 binding calls
+      - { path: "{{contract_doc}}", optional: true }   # the combined API document — the service as built, plus drafted operations it does not serve yet
   - id: gen_frontend
     condition: "{{fe_mode}} == bootstrap"
     action: agent_generate
@@ -1495,9 +1767,16 @@ workflow:
         parameters, request and response field names and their casing, status codes and
         error codes. Never take a route, a field name or a paging convention from memory,
         from convention or from the loaded standards' examples: the document is what the
-        built service actually answers. A §5 row whose id the document does not have is a
-        broken binding — realise the screen, leave that call unbound, report the element
-        `blocked` naming the id, and never guess a substitute.
+        service answers. An operation marked `x-aw-draft` is one the backend plan
+        describes and the service does not serve yet: bind to it exactly like any other,
+        through the client, and never stub, mock or fake its response in production code.
+      - A BINDING THAT WAITS ON AN OPEN CONTRACT REQUEST (open now: [{{req_open_csv}}]) is
+        not broken: its operation is in no document because the backend has not answered. Realise
+        the screen or component in full, write nothing that pretends to call the service
+        where that call goes, mark the spot with a comment citing the RQ-n and the proposed
+        operation id, and report the element `done`. Any OTHER §5 row whose id the
+        document does not have is a broken binding — realise the screen, leave that call
+        unbound, report the element `blocked` naming the id, and never guess a substitute.
       - THE CLIENT: {{client_status}}. The client lives in this lane's client layer; a
         generated client is called, never edited.
       - THE CLIENT IS NOT AN AUTHORITY. A client-side validation or permission check
@@ -1541,7 +1820,7 @@ workflow:
       - { path: "{{frontend_plan}}", optional: true } # the master plan — READ ONLY, never amended here
       - { path: "{{domain_model}}", optional: true }  # the master model — the ubiquitous language as it stands BEFORE this change
       - { path: .appweaver/memory/constitution.ui.md, optional: true }
-      - { path: "{{contract_doc}}", optional: true }  # the service's API document as BUILT — what every binding row calls
+      - { path: "{{contract_doc}}", optional: true }  # the combined API document — the service as built, plus drafted operations it does not serve yet
   - id: gen_frontend_delta
     condition: "{{fe_mode}} == delta"
     action: agent_generate
@@ -1626,6 +1905,8 @@ workflow:
         the document and take EVERYTHING about the call from it — route, verb, path and
         query parameters, request and response field names and their casing, status
         codes and error codes — never from memory, convention or the standards' examples.
+        An operation marked `x-aw-draft` is planned and not served yet: bind to it through
+        the client like any other, and never stub, mock or fake its response.
         A binding whose id the document does not have is broken: leave that call unbound,
         report the element `blocked` naming the id, and never guess a substitute.
       - THE CLIENT: {{client_status}}. The client lives in this lane's client layer; a
@@ -1706,8 +1987,10 @@ workflow:
         file is called; report it `done`.
       - A binding calls the operation its id names in the service's API document
         ({{contract_status}}), taking route, verb, parameters, field names and status codes
-        from there, through the client ({{client_status}}). An id the document does not
-        have stays `blocked`; never guess a substitute.
+        from there, through the client ({{client_status}}). A binding that waits on an open
+        contract request (open now: [{{req_open_csv}}]) is marked with a comment citing the RQ-n and
+        its element reported `done`; any other id the document does not have stays
+        `blocked`; never guess a substitute.
       - If an element cannot be realised, do not work around it: report it `blocked` and
         say what stops you. A plan that is wrong is fixed in plan / analyze-plan.
       - Report every listed element in an `elements` list in your closing JSON block:
@@ -1871,6 +2154,9 @@ outputs:
   frontend_implemented: "{{fe_go}}"
   frontend_plan: "{{fe_plan}}"         # the document the frontend lane generated FROM
   frontend_files: "{{fe_files}}"
+  api_document: "{{export_doc}}"       # exported from the service in this run (backend lane) — commit it, it is how the frontend developer receives the surface
+  frontend_api_document: "{{contract_doc}}"   # what the frontend bound to: the export plus the drafted operations it does not serve yet (not committed)
+  contract_requests: "{{req_summary}}" # the frontend plan's RQ-n requests and the backend plan's answers
   # Every plan element realised, per lane — `true` for a lane that did not generate.
   # `*_completion_pass` says whether the first pass left gaps a second one had to close.
   # `*_outcome` is the one word for what the lane did: complete (it generated and every
@@ -1895,10 +2181,16 @@ outputs:
   # Bootstrap path only. tracked=false means this feature has not been through a master
   # analyze-plan run since the gate began leaving a receipt — an unknown, not a stale plan,
   # and it blocks nothing.
-  plan_gate_tracked: "{{gate_tracked}}"
-  plan_gate_fresh: "{{gate_fresh}}"
-  plan_gate_at: "{{gate_at}}"
-  plan_gate_verdict: "{{gate_verdict}}"
-  plan_gate_routed_to_specify: "{{gate_routed_csv}}"   # open spec/model gaps this code does not cover
-  note: "Lanes come from .appweaver/stacks.json — backend declared {{be_declared}} (ready {{be_runnable}}, implemented {{be_go}}), frontend declared {{fe_declared}} (ready {{fe_runnable}}, implemented {{fe_go}}). A declared lane that was skipped printed its reason above and did not stop the other one; an undeclared lane produces nothing and that is not a failure. Each generating lane read its PLAN for what to build and {{domain_model}} for what the domain is — plus {{delta_model}} on the delta path, since the master model does not carry the change until finalize-delta merges it. Every one of those documents was READ and none was written: this phase generates code and nothing else. Each lane's outcome is backend={{be_outcome}}, frontend={{fe_outcome}} — `already-implemented` means the lane wrote no files because every plan element was already realised in its lane root folder, which is the correct result of re-running implement on a finished feature and not a failure. On the bootstrap path the plans were checked against analyze-plan's receipt before anything generated (tracked={{gate_tracked}}, fresh={{gate_fresh}}, gated {{gate_at}}) — tracked=false means this feature has never passed analyze-plan since the gate began recording what it proved, which is an unknown rather than a stale plan and blocks nothing; run /appweaver analyze-plan once to start the record."
+  working_lane: "{{working_lane}}"     # the developer's working lane(s) — .appweaver/lane.json
+  backend_plan_gate_tracked: "{{be_gate_tracked}}"
+  backend_plan_gate_fresh: "{{be_gate_fresh}}"
+  backend_plan_gate_at: "{{be_gate_at}}"
+  backend_plan_gate_verdict: "{{be_gate_verdict}}"
+  backend_plan_gate_routed_to_specify: "{{be_gate_routed_csv}}"    # open spec/model gaps this code does not cover
+  frontend_plan_gate_tracked: "{{fe_gate_tracked}}"
+  frontend_plan_gate_fresh: "{{fe_gate_fresh}}"
+  frontend_plan_gate_at: "{{fe_gate_at}}"
+  frontend_plan_gate_verdict: "{{fe_gate_verdict}}"
+  frontend_plan_gate_routed_to_specify: "{{fe_gate_routed_csv}}"
+  note: "Lanes come from .appweaver/stacks.json, and the ones you work on from .appweaver/lane.json (`{{working_lane}}`) — backend declared {{be_declared}} (worked {{be_working}}, ready {{be_runnable}}, implemented {{be_go}}), frontend declared {{fe_declared}} (worked {{fe_working}}, ready {{fe_runnable}}, implemented {{fe_go}}). A declared lane you do not work on is left to its developer and is not reported here. A declared lane that was skipped printed its reason above and did not stop the other one; an undeclared lane produces nothing and that is not a failure. Each generating lane read its PLAN for what to build and {{domain_model}} for what the domain is — plus {{delta_model}} on the delta path, since the master model does not carry the change until finalize-delta merges it. Every one of those documents was READ and none was written: this phase generates code and nothing else. Each lane's outcome is backend={{be_outcome}}, frontend={{fe_outcome}} — `already-implemented` means the lane wrote no files because every plan element was already realised in its lane root folder, which is the correct result of re-running implement on a finished feature and not a failure. On the bootstrap path each working lane's plan was checked against that lane's analyze-plan receipt before anything generated (backend tracked={{be_gate_tracked}}, fresh={{be_gate_fresh}}, gated {{be_gate_at}}; frontend tracked={{fe_gate_tracked}}, fresh={{fe_gate_fresh}}, gated {{fe_gate_at}}) — tracked=false means that lane has never passed analyze-plan since the gate began recording what it proved, which is an unknown rather than a stale plan and blocks nothing; run /appweaver analyze-plan once to start the record."
   next: "This run was mode `{{mode}}`, change `{{active_change}}` (empty on the bootstrap path). BOOTSTRAP → /appweaver build → analyze-slice → run. DELTA → /appweaver build → analyze-slice-delta {{active_change}} → finalize-delta → analyze-slice → close-delta, with the change still OPEN throughout — compile first, then analyze-slice-delta verifies that every element the delta plans marked ADDED or MODIFIED is actually in the code with a paired test (the gate that catches a lane you declined at the prompt above), then finalize-delta merges it into spec.md + the context's domain-model.md while leaving it open, analyze-slice verifies the slice against those merged masters while a red result is still recoverable, and close-delta LAST archives the change and bumps the version."