aw-spec-cli 0.1.20 → 0.1.22

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

@@ -47,9 +47,10 @@
 # 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 proved 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 that HAS a receipt and no longer matches it stops.
+# 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.
 # 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
@@ -86,11 +87,22 @@
 #   • FRONTEND — `## /aw-spec-implement-ui`, both paths. There was never a delta heading
 #     for this lane because the delta half of it was never built; it is built here.
 #
-# ONE SUBTREE PER LANE. Each lane owns the source path stacks.json declares for it and
-# writes nothing outside it. A file written elsewhere belongs to the other lane or to no
-# lane at all, and the project gate is deliberately stricter for the frontend: a manifest
-# found only elsewhere in the repository is the service lane's, and accepting it is how a
-# frontend that was never scaffolded is generated into anyway and reports green.
+# TWO PATHS PER LANE. Each lane owns the source path stacks.json declares for it and the
+# test path lane-verify resolves beside it — `tests/` next to a .NET `src/`, the source
+# path itself for a stack that keeps its tests inside — and writes nothing outside them.
+# The one exception is registering a test project the lane had to create, in whatever
+# file the lane's test command discovers tests through (a .NET solution file). A file
+# written elsewhere belongs to the other lane or to no lane at all, and the project gate
+# is deliberately stricter for the frontend: a manifest found only elsewhere in the
+# repository is the service lane's, and accepting it is how a frontend that was never
+# scaffolded is generated into anyway and reports green.
+#
+# A FILE LIST IS NOT A FINISHED LANE. Each generating lane is handed its plan's element
+# list and reports every element back as done or blocked; `plan-coverage` then checks the
+# code under the lane's source path for every identifier the plan introduces. Whatever
+# either check leaves open gets one completion pass, and anything still open after it
+# stops the run once both lanes have generated — so a pass that stopped at five use-cases
+# of seven is reported, not shipped.
 #
 # A LANE'S GAP DISABLES THAT LANE, NOT THE RUN. Three things a lane needs are checked per
 # lane and reported per lane: its source path is on disk, its plan is there, and a project
@@ -116,7 +128,7 @@
 
 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 source path, 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.4.0
+version: 3.10.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -162,19 +174,23 @@ vars:
   delta_frontend_plan: ""
   delta_frontend_plan_exists: "false"
   wave: ""
-  # THE GATE RECEIPT — was this feature's plan pair ever PROVEN against this spec, and has
-  # anything moved since. analyze-plan writes it on a green 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.
+  # THE GATE RECEIPT — was this feature's plan pair checked against this spec, with what
+  # 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 no longer matches: that tree has been through
-  # the gate once, so the bytes moving since is a fact, not an absence of one.
+  # 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"
   # 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.
@@ -189,6 +205,23 @@ vars:
   be_go: "false"
   be_mode: "skip"              # skip | bootstrap | delta
   be_files: []
+  # COMPLETENESS, per lane — see step 8b and the checks after each lane generates.
+  be_element_names: ""
+  be_existing_text: "  (not resolved)"
+  be_reserved: ""
+  be_collisions: ""
+  be_collisions_text: "none"
+  be_existing_count: "0"
+  be_elements: []
+  be_more_files: []
+  be_elements_more: []
+  be_complete: "true"
+  be_outcome: ""            # complete | already-implemented | gaps | no-plan-elements
+  be_satisfied: "false"     # the lane was already fully realised, so this run wrote nothing
+  be_coverage_note: ""
+  be_completion_ran: "false"
+  be_gap_names: ""
+  be_gaps_text: "none"
   fe_plan: ""
   fe_plan_ok: "false"
   fe_project_ok: "false"
@@ -198,6 +231,23 @@ vars:
   fe_go: "false"
   fe_mode: "skip"              # skip | bootstrap | delta
   fe_files: []
+  fe_element_names: ""
+  fe_existing_text: "  (not resolved)"
+  fe_reserved: ""
+  fe_collisions: ""
+  fe_collisions_text: "none"
+  fe_existing_count: "0"
+  fe_elements: []
+  fe_more_files: []
+  fe_elements_more: []
+  fe_complete: "true"
+  fe_outcome: ""
+  fe_satisfied: "false"
+  fe_coverage_note: ""
+  fe_completion_ran: "false"
+  fe_gap_names: ""
+  fe_gaps_text: "none"
+  lanes_complete: "true"
   generate_any: "false"
   record_edges: "false"
   overview_ok: "false"
@@ -245,6 +295,7 @@ workflow:
       - { name: be_declared,    from: "$.backend_declared" }
       - { name: be_lane_id,     from: "$.backend_lane_id" }
       - { name: be_source_path, from: "$.backend_source_path" }
+      - { name: be_test_path,   from: "$.backend_test_path" }
       - { name: be_root_exists, from: "$.backend_root_exists" }
       - { name: be_profile,     from: "$.backend_profile" }
       - { name: be_title,       from: "$.backend_title" }
@@ -252,9 +303,11 @@ workflow:
       - { name: be_ecosystem,   from: "$.backend_ecosystem" }
       - { name: be_build,       from: "$.backend_build" }
       - { name: be_test,        from: "$.backend_test" }
+      - { name: be_reserved,    from: "$.backend_reserved_csv" }
       - { name: fe_declared,    from: "$.frontend_declared" }
       - { name: fe_lane_id,     from: "$.frontend_lane_id" }
       - { name: fe_source_path, from: "$.frontend_source_path" }
+      - { name: fe_test_path,   from: "$.frontend_test_path" }
       - { name: fe_root_exists, from: "$.frontend_root_exists" }
       - { name: fe_profile,     from: "$.frontend_profile" }
       - { name: fe_title,       from: "$.frontend_title" }
@@ -262,6 +315,7 @@ workflow:
       - { name: fe_ecosystem,   from: "$.frontend_ecosystem" }
       - { name: fe_build,       from: "$.frontend_build" }
       - { name: fe_test,        from: "$.frontend_test" }
+      - { name: fe_reserved,    from: "$.frontend_reserved_csv" }
 
   - id: require_lanes
     action: verify_context
@@ -425,11 +479,15 @@ 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 when it
-  #     passed — spec.md, the context's domain-model.md and each gated lane plan. 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 — 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.
+  #
+  #     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.
   #
   #     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
@@ -441,25 +499,41 @@ workflow:
     subcommand: plan-gate-check
     args: ["--feature-dir", "{{feature_dir}}"]
     outputs:
-      - { name: gate_tracked, from: "$.tracked" }
-      - { name: gate_fresh,   from: "$.gate_fresh" }
-      - { name: gate_reason,  from: "$.reason" }
-      - { name: gate_at,      from: "$.gated" }
+      - { 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" }
 
   #     The ordered assignment is the AND: only a TRACKED feature can lower the flag, and
-  #     what lowers it is the gate no longer being fresh. An untracked one never reaches
+  #     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"
     action: set
-    vars: { may_generate: "{{gate_fresh}}" }
+    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 — the master plans are no longer the ones analyze-plan passed: {{gate_reason}}. This phase generates from the plans and does NOT read the spec, on the strength of that gate having conformed them to it, so generating now would realise a plan against requirements nobody checked it against. 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."
+    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"
+    action: set
+    vars: { gate_no_routed: "false" }
+
+  - id: warn_routed_gaps
+    action: verify_context
+    require_true: 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."
 
   # 4. THE PROJECT each declared lane generates INTO. Deterministic structure gate:
   #    detect-project searches the LANE'S OWN subtree for an ecosystem manifest (.sln/
@@ -575,7 +649,7 @@ workflow:
   - id: ask_backend
     condition: "{{be_runnable}} == true"
     action: ask
-    prompt: "Implement the BACKEND lane now? Lane `{{be_lane_id}}` — {{be_title}}, {{be_language}} ({{be_ecosystem}}) — generating from {{be_plan}} into {{be_source_path}}."
+    prompt: "Implement the BACKEND lane now? Lane `{{be_lane_id}}` — {{be_title}}, {{be_language}} ({{be_ecosystem}}) — generating from {{be_plan}} into {{be_source_path}}, tests into {{be_test_path}}."
     options: ["yes", "no"]
     answer_var: be_answer
   - id: be_go_set
@@ -586,7 +660,7 @@ workflow:
   - id: ask_frontend
     condition: "{{fe_runnable}} == true"
     action: ask
-    prompt: "Implement the FRONTEND lane now? Lane `{{fe_lane_id}}` — {{fe_title}}, {{fe_language}} ({{fe_ecosystem}}) — generating from {{fe_plan}} into {{fe_source_path}}."
+    prompt: "Implement the FRONTEND lane now? Lane `{{fe_lane_id}}` — {{fe_title}}, {{fe_language}} ({{fe_ecosystem}}) — generating from {{fe_plan}} into {{fe_source_path}}, tests into {{fe_test_path}}."
     options: ["yes", "no"]
     answer_var: fe_answer
   - id: fe_go_set
@@ -616,6 +690,69 @@ workflow:
     action: set
     vars: { fe_mode: "{{mode}}" }
 
+  # 8b. EACH GENERATING LANE'S ELEMENT LIST, read off its plan by plan-coverage. The
+  #     generation prompt carries it, and the model reports every name on it — so an
+  #     element it did not get to is declared rather than silently absent.
+  - id: be_plan_elements
+    condition: "{{be_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{be_plan}}", "--kind", "backend", "--mode", "{{be_mode}}", "--list-only", "--reserved", "{{be_reserved}}"]
+    outputs:
+      - { name: be_element_names,   from: "$.names_text" }
+      - { name: be_collisions,      from: "$.collisions_csv" }
+      - { name: be_collisions_text, from: "$.collisions_text" }
+  - id: fe_plan_elements
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{fe_plan}}", "--kind", "frontend", "--mode", "{{fe_mode}}", "--list-only", "--reserved", "{{fe_reserved}}"]
+    outputs:
+      - { name: fe_element_names,   from: "$.names_text" }
+      - { name: fe_collisions,      from: "$.collisions_csv" }
+      - { name: fe_collisions_text, from: "$.collisions_text" }
+
+  # 8c. THE CODE THAT IS ALREADY THERE, per lane, from the aggregate's OKF concept. This
+  #     is the step that WRITES code, and it was the only one that resolved no source at
+  #     all — plan, delta-plan, analyze-slice, build and run all read the real tree this
+  #     way. Without it a lane extending a shared aggregate had to go and discover the
+  #     established conventions for itself, or not bother, which is how two features end
+  #     up spelling the same pattern two ways.
+  #
+  #     A PATH LIST, not file contents: the generation steps declare `tools: Read` and open
+  #     what they need, because a brownfield tree does not fit in a payload. Nothing is
+  #     truncated — a file left off the list is a file the model does not know to EXTEND
+  #     and may regenerate instead.
+  #
+  #     `--under` narrows the concept to the lane's own two subtrees. A concept spans every
+  #     lane that realises the aggregate, so without it the backend pass is handed the UI's
+  #     files — a subtree it is forbidden to write into two rules later.
+  #
+  #     Read-only, and greenfield-safe: no concept yet exits 0 with count 0, which is the
+  #     first feature on a fresh tree and blocks nothing.
+  - id: be_existing_code
+    condition: "{{be_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{be_source_path}}", "--under", "{{be_test_path}}"]
+    outputs:
+      - { name: be_existing_text,  from: "$.paths_text" }
+      - { name: be_existing_count, from: "$.count" }
+  - id: fe_existing_code
+    condition: "{{fe_go}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{fe_source_path}}", "--under", "{{fe_test_path}}"]
+    outputs:
+      - { name: fe_existing_text,  from: "$.paths_text" }
+      - { name: fe_existing_count, from: "$.count" }
+
   # 9. Each generating lane's code-generation rule files → sticky standards (configuration,
   #    not hardcoded). Loaded only for a lane that is actually going to generate, and the
   #    backend's heading is keyed by mode (see the header). No blocking gate: an
@@ -698,15 +835,47 @@ workflow:
         loaded standards describe a DIFFERENT stack than the one above, the lane wins on
         language and layout — the standards' stack-specific mechanics do not apply, so
         follow their INTENT and STOP to surface the mismatch in your summary.
-      - WRITE ONLY UNDER `{{be_source_path}}` — the source path the `{{be_lane_id}}` lane
-        declares in .appweaver/stacks.json. That subtree is this lane's, and a file outside
-        it belongs to another lane or to no lane at all. NEVER write into the frontend
-        lane's subtree, not even to consume a contract. Do not create a parallel source
-        tree because the layout inside it is unfamiliar; if the plan needs a place this
-        subtree has no home for, STOP and surface it.
+      - WRITE ONLY INTO THE LANE'S TWO PATHS, both resolved for the `{{be_lane_id}}` lane
+        from .appweaver/stacks.json: production code under `{{be_source_path}}`, paired
+        tests under `{{be_test_path}}` (the same directory when the stack keeps its tests
+        inside its source). Those subtrees are this lane's, and a file outside them belongs
+        to another lane or to no lane at all. NEVER write into the frontend lane's subtree,
+        not even to consume a contract. Do not create a parallel source tree because the
+        layout inside them is unfamiliar; if the plan needs a place they have no home for,
+        STOP and surface it.
+      - NAMES THIS STACK ALREADY DEFINES: {{be_collisions_text}}.
+        Where that list is not `none`, the plan's name is RIGHT and stays exactly as the
+        plan spells it — it is the ubiquitous language, and renaming a domain type to
+        dodge a framework one is never the answer. What changes is how it is WRITTEN at
+        the use site: qualify it with its own enclosing namespace segment, every time.
+        In C# that is `Domain.Route`, not a bare `Route`, wherever the type is named —
+        declarations, parameters, return types, generic arguments and doc comments.
+        The conflict is INVISIBLE in the file: the framework name arrives through an
+        implicit/ambient import and appears in no line of it, so a bare name looks fine,
+        compiles in your head, and fails the build as an ambiguous reference (C# CS0104).
+        Do not add a `using` alias and do not fully qualify the whole namespace path —
+        one convention, so two features never disambiguate the same name two ways.
+      - THE CODE THAT IS ALREADY THERE. This aggregate already has {{be_existing_count}} file(s) in
+        this lane, listed from its OKF concept:
+        {{be_existing_text}}
+        READ the ones your elements touch BEFORE writing anything. They are this
+        codebase's established conventions — the identifier pattern, the persistence and mapping shape, the endpoint
+        and handler wiring, the error and DTO style — and new code follows
+        them rather than introducing a second way of doing the same thing. A listed file
+        that one of your elements maps onto is EXTENDED: add the member, leave every
+        existing member byte-for-byte alone, and never regenerate, rename or move it.
+        Nothing is left off that list, so a path not on it does not exist yet. A count of
+        0 means this is the aggregate's first code in this lane and the conventions come
+        from the loaded standards instead.
+      - A MISSING TEST PROJECT IS CREATED, NEVER A REASON TO SKIP THE TESTS. When
+        `{{be_test_path}}` holds no test project yet, create one there as the loaded
+        testing standard describes, referencing the production project it tests, and
+        register it wherever `{{be_test}}` discovers tests (for .NET, the solution file).
+        That registration is the ONLY edit allowed outside the lane's two paths; name the
+        file you edited in your summary.
       - Follow the project's folder/layer convention + the loaded coding-standards,
         dependency-policy and testing standards for HOW to structure, name and place files
-        WITHIN that subtree — the plan says WHAT to build; these standards (identical for
+        WITHIN those subtrees — the plan says WHAT to build; these standards (identical for
         every feature) say HOW.
       - COMPONENTS: when the plan's External Integrations table depends on a framework
         component (e.g. `IEmailService`, `IJobScheduler`), code against that component's
@@ -727,6 +896,12 @@ workflow:
         CN / DC / IC / US) from its Traceability section. Include tests for the constraints
         — e.g. an audit record is emitted, a DC-restricted field is NOT exposed on the
         public surface, an IC- projection round-trips.
+      - WIRE WHAT YOU BUILD, in this same pass. Every port, adapter, handler and endpoint
+        the plan introduces is registered in the lane's composition root as the plan's §4.3
+        Wiring states. A dependency that is injected and never bound COMPILES GREEN — a
+        container graph is not compile-checked — and fails on the first request that needs
+        it. Where the project registers by assembly scan or convention, confirm the new
+        type is actually covered by it rather than assuming it is.
       - Do NOT add behaviour the plan does not state, and do NOT omit any it does. If the
         plan looks wrong or incomplete, STOP and surface it (it is fixed in plan /
         analyze-plan) — never compensate from the spec or from memory.
@@ -740,8 +915,16 @@ workflow:
         one changed, STOP and surface it.
       - Where generated code depends on a plan Assumption (DA-n) or Workaround (WA-n), mark
         it with a comment citing that id so it is easy to revisit later.
+      - REPORT EVERY PLAN ELEMENT. The plan's elements, by name: {{be_element_names}}.
+        Add an `elements` list to your closing JSON block with one entry per name, spelled
+        exactly as listed: {"element": "<name>", "status": "done" | "blocked", "reason":
+        "<what stops it, when blocked>"}. `done` means it is realised in code now,
+        including one that already existed; `blocked` means you could not realise it. An
+        element missing from the list counts as not done, and the code is checked for
+        each name after this step.
     outputs:
       - { name: be_files, from: "$.files" }
+      - { name: be_elements, from: "$.elements" }
 
   # ═══════════ BACKEND LANE — delta, generate ONLY what the change adds ════════
   # The delta plan is the authoritative source of WHAT changed — analyze-plan-delta already
@@ -816,12 +999,42 @@ workflow:
         loaded standards describe a DIFFERENT stack than the one above, the lane wins on
         language and layout — follow the standards' INTENT and STOP to surface the
         mismatch in your summary.
-      - WRITE ONLY UNDER `{{be_source_path}}` — the source path the `{{be_lane_id}}` lane
-        declares. That subtree is this lane's, and a file outside it belongs to another
-        lane or to no lane at all. NEVER write into the frontend lane's subtree.
+      - WRITE ONLY INTO THE LANE'S TWO PATHS: production code under `{{be_source_path}}`,
+        paired tests under `{{be_test_path}}`. Those subtrees are this lane's, and a file
+        outside them belongs to another lane or to no lane at all. NEVER write into the
+        frontend lane's subtree.
+      - NAMES THIS STACK ALREADY DEFINES: {{be_collisions_text}}.
+        Where that list is not `none`, the plan's name is RIGHT and stays exactly as the
+        plan spells it — it is the ubiquitous language, and renaming a domain type to
+        dodge a framework one is never the answer. What changes is how it is WRITTEN at
+        the use site: qualify it with its own enclosing namespace segment, every time.
+        In C# that is `Domain.Route`, not a bare `Route`, wherever the type is named —
+        declarations, parameters, return types, generic arguments and doc comments.
+        The conflict is INVISIBLE in the file: the framework name arrives through an
+        implicit/ambient import and appears in no line of it, so a bare name looks fine,
+        compiles in your head, and fails the build as an ambiguous reference (C# CS0104).
+        Do not add a `using` alias and do not fully qualify the whole namespace path —
+        one convention, so two features never disambiguate the same name two ways.
+      - THE CODE THAT IS ALREADY THERE. This aggregate already has {{be_existing_count}} file(s) in
+        this lane, listed from its OKF concept:
+        {{be_existing_text}}
+        READ the ones your elements touch BEFORE writing anything. They are this
+        codebase's established conventions — the identifier pattern, the persistence and mapping shape, the endpoint
+        and handler wiring, the error and DTO style — and new code follows
+        them rather than introducing a second way of doing the same thing. A listed file
+        that one of your elements maps onto is EXTENDED: add the member, leave every
+        existing member byte-for-byte alone, and never regenerate, rename or move it.
+        Nothing is left off that list, so a path not on it does not exist yet. A count of
+        0 means this is the aggregate's first code in this lane and the conventions come
+        from the loaded standards instead.
+      - A MISSING TEST PROJECT IS CREATED, NEVER A REASON TO SKIP THE TESTS. When
+        `{{be_test_path}}` holds no test project yet, create one there as the loaded
+        testing standard describes and register it wherever `{{be_test}}` discovers tests
+        (for .NET, the solution file) — the ONLY edit allowed outside the lane's two paths;
+        name the file you edited in your summary.
       - Follow the project's EXISTING folder/layer convention + the loaded
         coding-standards, dependency-policy and testing standards for HOW to structure,
-        name and place files WITHIN that subtree. Match the surrounding code already there.
+        name and place files WITHIN those subtrees. Match the surrounding code already there.
       - Realise EVERY ADDED/MODIFIED delta element as code: one file per Domain type /
         Application use-case / API endpoint / Infrastructure adapter, placed by layer.
         Preserve the ubiquitous-language names verbatim. Enforce each new/changed Domain
@@ -838,20 +1051,114 @@ workflow:
         The spec is not in context: take the id from the plan and cite it verbatim, never
         guess one from the element's shape. A delta-plan element that names no id is a
         planning gap — surface it rather than inventing the traceability.
+      - WIRE WHAT YOU BUILD, in this same pass: every port, adapter, handler and endpoint
+        this change introduces is registered in the lane's composition root, as the delta
+        plan states. A dependency injected and never bound compiles green and fails on the
+        first request; where registration is by assembly scan, confirm the new type is
+        covered by it.
       - REGRESSION: for each element in the delta plan's "Regression targets", verify (add
         or adjust a test where needed) that the existing behaviour still holds after a
         shared element changed — but do NOT rewrite that existing behaviour.
       - Where generated code depends on a delta Assumption (DA-n) or Workaround (WA-n),
         mark it with a comment citing that id.
+      - REPORT EVERY DELTA ELEMENT. The delta plan's ADDED and MODIFIED elements, by name:
+        {{be_element_names}}. Add an `elements` list to your closing JSON block with one
+        entry per name, spelled exactly as listed: {"element": "<name>", "status": "done"
+        | "blocked", "reason": "<what stops it, when blocked>"}. An element missing from
+        the list counts as not done, and the code is checked for each name after this step.
     outputs:
       - { name: be_files, from: "$.files" }
+      - { name: be_elements, from: "$.elements" }
 
-  - id: verify_be_files
+  # WHAT THIS LANE ACTUALLY DID, judged on the code rather than on the file count. An empty
+  # file list has two opposite meanings — the lane is already built, or the pass achieved
+  # nothing — and only the code tells them apart, so plan-coverage runs FIRST and the gate
+  # below reads its verdict. `--generated` carries the file list: empty makes this the
+  # already-implemented probe, judged on the code alone, because an element no scan can
+  # confirm (a port, an adapter) was confirmed by the run that created it.
+  #
+  # PARTIAL GENERATION. A non-empty file list is not a finished lane either: a pass that
+  # stopped part-way returns the files it did write. Coverage then checks every plan element
+  # two ways — the code must name each identifier the plan introduces, and the model's own
+  # report must say each element is done — and whatever fails either check gets ONE
+  # completion pass in the same envelope. What is still missing after it stops the run at
+  # step 10b, once both lanes have had their turn.
+  - id: be_coverage
     condition: "{{be_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{be_plan}}", "--kind", "backend", "--mode", "{{be_mode}}", "--source-path", "{{be_source_path}}", "--test-path", "{{be_test_path}}", "--reported", "{{be_elements}}", "--generated", "{{be_files}}"]
+    outputs:
+      - { name: be_complete,  from: "$.ok" }
+      - { name: be_outcome,   from: "$.outcome" }
+      - { name: be_gap_names, from: "$.gap_names_csv" }
+      - { name: be_gaps_text, from: "$.gaps_text" }
+      - { name: be_coverage_note, from: "$.message" }
+
+  # NOTHING TO DO IS AN OUTCOME, not a failure. A lane whose every plan element is already
+  # realised writes no files, and that is the correct result of re-running implement on a
+  # finished feature — the other lane may still have work, and the OKF merge and the edges
+  # downstream are reconcile-on-write, so the run carries on.
+  - id: be_satisfied_flag
+    condition: "{{be_outcome}} == already-implemented"
+    action: set
+    vars: { be_satisfied: "true" }
+
+  # The one empty-file case that IS unexplained: a plan no element could be read from
+  # proves nothing about the code, so a pass that wrote nothing against it has no evidence
+  # either way. That is the template-not-filled case the old file-count gate was reaching
+  # for, and it is the only one left that stops the run here.
+  - id: verify_be_evidence
+    condition: "{{be_outcome}} == no-plan-elements"
     action: verify_context
     require_non_empty: be_files
     on_empty: stop
-    on_empty_message: "The backend lane generated no files. Ensure {{be_plan}} is a FILLED plan (not the empty template) and that it passed its gate — /appweaver analyze-plan for a master, /appweaver analyze-plan-delta for a change — then re-run implement."
+    on_empty_message: "The backend lane generated no files, and no plan element could be read from {{be_plan}} — so there is no evidence of what it should have built. The usual cause is an unfilled plan (still the empty template) or one whose headings do not follow the plan template. Fill it with /appweaver plan, check it with /appweaver analyze-plan (analyze-plan-delta for a change), then re-run implement."
+  - id: be_completion_flag
+    condition: "{{be_complete}} == false"
+    action: set
+    vars: { be_completion_ran: "true" }
+  - id: gen_backend_complete
+    condition: "{{be_completion_ran}} == true"
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      COMPLETE the backend lane. The generation pass before this one left these plan
+      elements unrealised: {{be_gap_names}}.
+      Why each was flagged: {{be_gaps_text}}.
+      The same plan, domain model and constitution are in context, and every rule of that
+      pass still holds: realise each element STRICTLY as the plan states it; production
+      code only under `{{be_source_path}}` and paired tests only under `{{be_test_path}}`;
+      the `{{be_lane_id}}` lane's stack ({{be_title}}, {{be_language}}) and no other;
+      shared aggregate files EXTENDED, never regenerated; nothing the plan does not state.
+      Rules:
+      - Realise each listed element now, with its paired test citing the spec id the plan
+        gives it. Leave what the earlier pass wrote as it is, except to extend a shared file.
+      - Use the plan's name for each element EXACTLY. An element that already exists
+        under a different name is renamed to the plan's name, with its references — the
+        plan's names are the ubiquitous language.
+      - An element the plan names by intent (a port, an adapter, an endpoint route) is done
+        when the code realises it, whatever the framework calls it; report it `done`.
+      - 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:
+        {"element": "<name as listed>", "status": "done" | "blocked", "reason": "…"}.
+    outputs:
+      - { name: be_more_files,    from: "$.files" }
+      - { name: be_elements_more, from: "$.elements" }
+  - id: be_coverage_recheck
+    condition: "{{be_completion_ran}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{be_plan}}", "--kind", "backend", "--mode", "{{be_mode}}", "--source-path", "{{be_source_path}}", "--test-path", "{{be_test_path}}", "--reported", "{{be_elements}}", "--reported", "{{be_elements_more}}"]
+    outputs:
+      - { name: be_complete,  from: "$.ok" }
+      - { name: be_outcome,   from: "$.outcome" }
+      - { name: be_gap_names, from: "$.gap_names_csv" }
+      - { name: be_gaps_text, from: "$.gaps_text" }
 
   # OKF knowledge — the feature has ONE concept across both lanes and both modes, so every
   # lane's files JOIN it rather than replace it (--merge unions them with what is already
@@ -868,6 +1175,15 @@ workflow:
     args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{be_files}}", "--merge", "--origin", "greenfield"]
     outputs:
       - { name: okf_concept, from: "$.concept" }
+  - id: xref_concept_backend_more
+    condition: "{{be_completion_ran}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{be_more_files}}", "--merge", "--origin", "greenfield"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
 
   # ══════════════ 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
@@ -932,16 +1248,46 @@ workflow:
         re-decide anything already fixed there. If the loaded standards describe a
         DIFFERENT stack than the one above, the lane wins on framework and layout — follow
         the standards' INTENT and STOP to surface the mismatch in your summary.
-      - WRITE ONLY UNDER `{{fe_source_path}}` — the source path the `{{fe_lane_id}}` lane
-        declares. That subtree is this lane's; a file outside it belongs to the service
-        lane or to no lane. NEVER touch the service lane's code, not even to add a field
-        the UI wants: a gap in the service surface is a contract delta raised back to that
-        lane. Do not create a parallel source tree because the layout inside this one is
-        unfamiliar; if the plan needs a place this subtree has no home for, STOP and
-        surface it.
+      - WRITE ONLY INTO THE LANE'S TWO PATHS, both resolved for the `{{fe_lane_id}}` lane:
+        production code under `{{fe_source_path}}`, paired tests under `{{fe_test_path}}`
+        (the same directory when the stack keeps its tests inside its source). Those
+        subtrees are this lane's; a file outside them belongs to the service lane or to no
+        lane. NEVER touch the service lane's code, not even to add a field the UI wants: a
+        gap in the service surface is a contract delta raised back to that lane. Do not
+        create a parallel source tree because the layout inside this one is unfamiliar; if
+        the plan needs a place this subtree has no home for, STOP and surface it.
+      - NAMES THIS STACK ALREADY DEFINES: {{fe_collisions_text}}.
+        Where that list is not `none`, the plan's name is RIGHT and stays exactly as the
+        plan spells it — it is the ubiquitous language, and renaming a domain type to
+        dodge a framework one is never the answer. What changes is how it is WRITTEN at
+        the use site: qualify it with its own enclosing namespace segment, every time.
+        In C# that is `Domain.Route`, not a bare `Route`, wherever the type is named —
+        declarations, parameters, return types, generic arguments and doc comments.
+        The conflict is INVISIBLE in the file: the framework name arrives through an
+        implicit/ambient import and appears in no line of it, so a bare name looks fine,
+        compiles in your head, and fails the build as an ambiguous reference (C# CS0104).
+        Do not add a `using` alias and do not fully qualify the whole namespace path —
+        one convention, so two features never disambiguate the same name two ways.
+      - THE CODE THAT IS ALREADY THERE. This aggregate already has {{fe_existing_count}} file(s) in
+        this lane, listed from its OKF concept:
+        {{fe_existing_text}}
+        READ the ones your elements touch BEFORE writing anything. They are this
+        codebase's established conventions — the component and screen layout, the server-action and data-fetch shape,
+        the state and error handling, the locale-catalogue mechanics — and new code follows
+        them rather than introducing a second way of doing the same thing. A listed file
+        that one of your elements maps onto is EXTENDED: add the member, leave every
+        existing member byte-for-byte alone, and never regenerate, rename or move it.
+        Nothing is left off that list, so a path not on it does not exist yet. A count of
+        0 means this is the aggregate's first code in this lane and the conventions come
+        from the loaded standards instead.
+      - A MISSING TEST SETUP IS CREATED, NEVER A REASON TO SKIP THE TESTS. When the lane
+        has no test project or test runner yet, set one up inside the lane's paths as the
+        loaded testing standard describes, so that `{{fe_test}}` runs the tests you write.
+        Anything outside the lane's two paths that must change for that is the ONLY such
+        edit allowed; name the file you edited in your summary.
       - Follow the UI constitution's folder structure, naming conventions and forbidden
         patterns, plus the loaded standards, for HOW to structure, name and place files
-        WITHIN that subtree — the plan says WHAT to build; these say HOW.
+        WITHIN those subtrees — the plan says WHAT to build; these say HOW.
       - REALISE EVERY PLAN ELEMENT, changing nothing about WHAT it specifies:
         • §1 — one route/screen per row, with the navigation shape and the access
           conditions the row states.
@@ -974,8 +1320,16 @@ workflow:
         feature. If one of them has to change, STOP and surface it.
       - Where generated code depends on a plan Assumption (DA-n) or Workaround (WA-n), mark
         it with a comment citing that id so it is easy to revisit later.
+      - REPORT EVERY PLAN ELEMENT. The plan's elements, by name: {{fe_element_names}}.
+        Add an `elements` list to your closing JSON block with one entry per name, spelled
+        exactly as listed: {"element": "<name>", "status": "done" | "blocked", "reason":
+        "<what stops it, when blocked>"}. `done` means it is realised in code now,
+        including one that already existed; `blocked` means you could not realise it. An
+        element missing from the list counts as not done, and the code is checked for
+        each name after this step.
     outputs:
       - { name: fe_files, from: "$.files" }
+      - { name: fe_elements, from: "$.elements" }
 
   # ═══════════ FRONTEND LANE — delta, generate ONLY what the change adds ═══════
   # The UI half of the CR loop, which never existed as its own command: the ⌛
@@ -1031,9 +1385,37 @@ workflow:
         `{{fe_test}}`. Generate in THAT framework and no other. Take the router, state
         approach, component library, design system and styling from the UI constitution +
         the loaded standards, and MATCH the code already in the tree.
-      - WRITE ONLY UNDER `{{fe_source_path}}`. NEVER touch the service lane's code, not
+      - WRITE ONLY INTO THE LANE'S TWO PATHS: production code under `{{fe_source_path}}`,
+        paired tests under `{{fe_test_path}}`. NEVER touch the service lane's code, not
         even to add a field the UI wants — a gap in the service surface is a contract delta
         raised back to that lane, never worked around in the client.
+      - NAMES THIS STACK ALREADY DEFINES: {{fe_collisions_text}}.
+        Where that list is not `none`, the plan's name is RIGHT and stays exactly as the
+        plan spells it — it is the ubiquitous language, and renaming a domain type to
+        dodge a framework one is never the answer. What changes is how it is WRITTEN at
+        the use site: qualify it with its own enclosing namespace segment, every time.
+        In C# that is `Domain.Route`, not a bare `Route`, wherever the type is named —
+        declarations, parameters, return types, generic arguments and doc comments.
+        The conflict is INVISIBLE in the file: the framework name arrives through an
+        implicit/ambient import and appears in no line of it, so a bare name looks fine,
+        compiles in your head, and fails the build as an ambiguous reference (C# CS0104).
+        Do not add a `using` alias and do not fully qualify the whole namespace path —
+        one convention, so two features never disambiguate the same name two ways.
+      - THE CODE THAT IS ALREADY THERE. This aggregate already has {{fe_existing_count}} file(s) in
+        this lane, listed from its OKF concept:
+        {{fe_existing_text}}
+        READ the ones your elements touch BEFORE writing anything. They are this
+        codebase's established conventions — the component and screen layout, the server-action and data-fetch shape,
+        the state and error handling, the locale-catalogue mechanics — and new code follows
+        them rather than introducing a second way of doing the same thing. A listed file
+        that one of your elements maps onto is EXTENDED: add the member, leave every
+        existing member byte-for-byte alone, and never regenerate, rename or move it.
+        Nothing is left off that list, so a path not on it does not exist yet. A count of
+        0 means this is the aggregate's first code in this lane and the conventions come
+        from the loaded standards instead.
+      - A MISSING TEST SETUP IS CREATED, NEVER A REASON TO SKIP THE TESTS: set one up
+        inside the lane's paths so that `{{fe_test}}` runs the tests you write, and name
+        any file outside them you had to edit for that in your summary.
       - STATES ARE PART OF THE CHANGE. Every interaction this delta adds or alters ships
         its FULL state set — loading, empty, error, permission-denied, in-flight — plus the
         validation timing, focus placement and keyboard reachability the delta plan states.
@@ -1055,15 +1437,86 @@ workflow:
         feature. If one of them has to change, STOP and surface it.
       - Where generated code depends on a delta Assumption (DA-n) or Workaround (WA-n),
         mark it with a comment citing that id.
+      - REPORT EVERY DELTA ELEMENT. The delta plan's ADDED and MODIFIED elements, by name:
+        {{fe_element_names}}. Add an `elements` list to your closing JSON block with one
+        entry per name, spelled exactly as listed: {"element": "<name>", "status": "done"
+        | "blocked", "reason": "<what stops it, when blocked>"}. An element missing from
+        the list counts as not done, and the code is checked for each name after this step.
     outputs:
       - { name: fe_files, from: "$.files" }
+      - { name: fe_elements, from: "$.elements" }
 
-  - id: verify_fe_files
+  # WHAT THIS LANE ACTUALLY DID — the frontend twin of the backend check above, including
+  # the already-implemented probe and the one empty-file case that still stops the run.
+  - id: fe_coverage
     condition: "{{fe_go}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{fe_plan}}", "--kind", "frontend", "--mode", "{{fe_mode}}", "--source-path", "{{fe_source_path}}", "--test-path", "{{fe_test_path}}", "--reported", "{{fe_elements}}", "--generated", "{{fe_files}}"]
+    outputs:
+      - { name: fe_complete,  from: "$.ok" }
+      - { name: fe_outcome,   from: "$.outcome" }
+      - { name: fe_gap_names, from: "$.gap_names_csv" }
+      - { name: fe_gaps_text, from: "$.gaps_text" }
+      - { name: fe_coverage_note, from: "$.message" }
+
+  - id: fe_satisfied_flag
+    condition: "{{fe_outcome}} == already-implemented"
+    action: set
+    vars: { fe_satisfied: "true" }
+
+  - id: verify_fe_evidence
+    condition: "{{fe_outcome}} == no-plan-elements"
     action: verify_context
     require_non_empty: fe_files
     on_empty: stop
-    on_empty_message: "The frontend lane generated no files. Ensure {{fe_plan}} is a FILLED plan (not the empty template) and that it passed its gate — /appweaver analyze-plan for a master, /appweaver analyze-plan-delta for a change — then re-run implement."
+    on_empty_message: "The frontend lane generated no files, and no plan element could be read from {{fe_plan}} — so there is no evidence of what it should have built. The usual cause is an unfilled plan (still the empty template) or one whose headings do not follow the plan template. Fill it with /appweaver plan-ui, check it with /appweaver analyze-plan (analyze-plan-delta for a change), then re-run implement."
+  - id: fe_completion_flag
+    condition: "{{fe_complete}} == false"
+    action: set
+    vars: { fe_completion_ran: "true" }
+  - id: gen_frontend_complete
+    condition: "{{fe_completion_ran}} == true"
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      COMPLETE the frontend lane. The generation pass before this one left these plan
+      elements unrealised: {{fe_gap_names}}.
+      Why each was flagged: {{fe_gaps_text}}.
+      The same plan, domain model and UI constitution are in context, and every rule of
+      that pass still holds: realise each element STRICTLY as the plan states it, with its
+      FULL state set; production code only under `{{fe_source_path}}` and paired tests
+      only under `{{fe_test_path}}`; the `{{fe_lane_id}}` lane's stack ({{fe_title}},
+      {{fe_language}}) and no other; never the service lane's code, the app shell, the
+      global layout or the design system; nothing the plan does not state.
+      Rules:
+      - Realise each listed element now, with its paired test citing the spec id the plan
+        gives it. Leave what the earlier pass wrote as it is.
+      - Use the plan's name for each element EXACTLY. An element that already exists
+        under a different name is renamed to the plan's name, with its references — the
+        plan's names are the ubiquitous language.
+      - A screen or a binding is done when the code realises it, whatever its route or
+        file is called; report it `done`.
+      - 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:
+        {"element": "<name as listed>", "status": "done" | "blocked", "reason": "…"}.
+    outputs:
+      - { name: fe_more_files,    from: "$.files" }
+      - { name: fe_elements_more, from: "$.elements" }
+  - id: fe_coverage_recheck
+    condition: "{{fe_completion_ran}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: plan-coverage
+    args: ["--plan", "{{fe_plan}}", "--kind", "frontend", "--mode", "{{fe_mode}}", "--source-path", "{{fe_source_path}}", "--test-path", "{{fe_test_path}}", "--reported", "{{fe_elements}}", "--reported", "{{fe_elements_more}}"]
+    outputs:
+      - { name: fe_complete,  from: "$.ok" }
+      - { name: fe_outcome,   from: "$.outcome" }
+      - { name: fe_gap_names, from: "$.gap_names_csv" }
+      - { name: fe_gaps_text, from: "$.gaps_text" }
 
   - id: xref_concept_frontend
     condition: "{{fe_go}} == true"
@@ -1074,6 +1527,34 @@ workflow:
     args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{fe_files}}", "--merge", "--origin", "greenfield"]
     outputs:
       - { name: okf_concept, from: "$.concept" }
+  - id: xref_concept_frontend_more
+    condition: "{{fe_completion_ran}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{fe_more_files}}", "--merge", "--origin", "greenfield"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
+
+  # 10b. A LANE LEFT INCOMPLETE STOPS THE RUN — after both lanes have generated and every
+  #      file written is recorded in the OKF concept, and before the edges, the Overview
+  #      and the after-hooks, which all assume a finished slice. Re-running implement
+  #      finishes the job: shared files are extended, and a file that exists is not
+  #      regenerated.
+  - id: lanes_incomplete_be
+    condition: "{{be_complete}} == false"
+    action: set
+    vars: { lanes_complete: "false" }
+  - id: lanes_incomplete_fe
+    condition: "{{fe_complete}} == false"
+    action: set
+    vars: { lanes_complete: "false" }
+  - id: require_complete_lanes
+    action: verify_context
+    require_true: lanes_complete
+    on_false: stop
+    on_false_message: "PARTIAL GENERATION — implement did not realise every plan element, even after one completion pass. Backend lane: {{be_gaps_text}}. Frontend lane: {{fe_gaps_text}}. Everything written so far is kept and recorded in the OKF concept. An element reported `blocked` names what stops it — a plan that is wrong is fixed with /appweaver plan (then analyze-plan or analyze-plan-delta). An element with no code under the lane's source path is still to be written, or was written under a name that is not the plan's: re-run /appweaver implement to finish, which extends existing files rather than regenerating them."
 
   # 11. CROSS-SLICE EDGES — a Cross-References row written into every SIBLING aggregate
   #     this one uses, read off the master backend plan (§1 References-by-id + its External
@@ -1181,15 +1662,34 @@ outputs:
   frontend_implemented: "{{fe_go}}"
   frontend_plan: "{{fe_plan}}"         # the document the frontend lane generated FROM
   frontend_files: "{{fe_files}}"
+  # 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
+  # element is realised), already-implemented (it wrote nothing because nothing was left
+  # to write), gaps, or no-plan-elements. `*_satisfied` is that second case alone.
+  backend_complete: "{{be_complete}}"
+  backend_outcome: "{{be_outcome}}"
+  backend_satisfied: "{{be_satisfied}}"
+  backend_coverage: "{{be_coverage_note}}"
+  backend_completion_pass: "{{be_completion_ran}}"
+  backend_more_files: "{{be_more_files}}"
+  frontend_complete: "{{fe_complete}}"
+  frontend_outcome: "{{fe_outcome}}"
+  frontend_satisfied: "{{fe_satisfied}}"
+  frontend_coverage: "{{fe_coverage_note}}"
+  frontend_completion_pass: "{{fe_completion_ran}}"
+  frontend_more_files: "{{fe_more_files}}"
   domain_model: "{{domain_model}}"     # the master model every generating lane read
   delta_model: "{{delta_model}}"       # its second half on the delta path — empty on the bootstrap path
   okf_concept: "{{okf_concept}}"
   xref_edge_count: "{{xref_edge_count}}"
-  # Bootstrap path only. tracked=false means this feature has never passed analyze-plan
-  # since the gate began leaving a receipt — an unknown, not a stale plan, and it blocks
-  # nothing.
+  # 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}}"
-  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. 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."
+  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 source path, 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."
   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."