aw-spec-cli 0.1.26 → 0.1.28

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

@@ -1,38 +1,48 @@
 # =============================================================================
-# aw-spec-foundation (orchestrator) — scaffold a project from a foundation bundle
+# aw-spec-foundation (orchestrator) — scaffold every declared lane, backend then frontend
 #
-# Almost entirely deterministic script orchestration (unpack the verified
-# byte-for-byte bundle, rename the sentinel); the model is used ONLY for the
-# optional DbContext merge when the reference sample is included. That merge
-# is an `agent_author` (decl `llm_generate` port): generation is READ-ONLY
-# under every strategy and the ENGINE writes the merged file, so sdk-apply
-# degrades to sdk. No standards/domain/hooks — pure scaffolding, so the merge
-# runs with include_standards: false and a narrow two-file context.
+# ONE RUN, EVERY LANE. The lanes come from .appweaver/stacks.json (select-stack is its sole
+# writer). The run takes the backend lane first and the frontend lane second. For each, a
+# lane that already holds files is asked about first — "Overwrite?", where "no" skips that
+# lane and nothing else is asked — and then the run lists what the lane can be built from
+# and the operator picks:
 #
-# Interactive confirmations (proceed / overwrite / reference sample) ride the
-# checkpoint channel under EVERY strategy.
+#   [pack]         a verified, compiling project unpacked byte-for-byte into the lane's
+#                  lane root folder with its sentinel renamed      -> modules/foundation-pack
+#   [spec]         a foundations/<ecosystem>/<Name>/*.spec.txt describing the project; an
+#                  agent builds it in the lane                -> modules/foundation-spec
+#   [manual spec]  the same, from a file path or text given at the prompt
+#   [skip]         leave the lane as it is
 #
-# A SCAFFOLD LANDS IN A LANE. The output directory is the SOURCE PATH of the lane being
-# scaffolded, read from .appweaver/stacks.json — never the repository root and never a
-# directory named on the command line. One bundle is one lane's project, so a repo with a
-# service and a UI is scaffolded by running this twice, once per lane, and each run's files
-# land in the subtree that lane owns. That is what makes every later phase's "write only
-# into your lane" rule true of the scaffold as well as of generated code: implement,
-# build, test and run all resolve the same path this unpacked into.
+# A lane kind that is not declared is reported and passed over; a lane that is declined,
+# skipped or fails is reported and the run moves on to the next one — the per-lane
+# modules RETURN, they never stop the run. Each lane's outcome is in the run's outputs,
+# which is where the operator reads it.
 #
-# The lane's TEST PATH is its second subtree, and for most backend stacks it is a sibling
-# of the source path rather than a directory inside it. A pack carrying its own test
-# project is unpacked like everything else and then has that tree lifted onto the lane's
-# test path — see .appweaver/scripts/python/aw-foundation.py for when that is a no-op.
+# A SCAFFOLD LANDS IN A LANE. A lane is one self-contained folder: a pack unpacks into it
+# exactly as packed — build files, source and tests together — and a spec build creates
+# the whole project inside it and may write nowhere else. The lane runs its commands in
+# that folder and keeps its tests there; a lane declared the classic way (code in src/,
+# solution and tests/ at the repository root) is reported and passed over, since a
+# project built inside src/ would not be found by a build run at the root. That is what
+# keeps every later phase's "write only into your lane" rule true of the scaffold as well
+# as of generated code: implement, build, test and run all resolve the same paths.
 #
-# Lanes must therefore be declared FIRST: /appweaver select-stack is the sole writer of
-# stacks.json and the first command of both sequences.
+# WHAT A LANE IS OFFERED. Bundles are filtered by the lane's ecosystem, then by the
+# `# kind:` and `# profiles:` header lines of each pack/spec — an ecosystem is shared by
+# stacks that cannot use each other's scaffold (Next.js, Angular and the Express backend
+# are all `node`). A pack or spec with no `# kind:` line is a backend one.
+#
+# A SPEC BUILD FOLLOWS THE PROJECT'S TECHNICAL RULES. They are mapped per kind in the
+# active project's tech-rule-bindings.md (the folder under guardrails/ that
+# .appweaver/domain.json names — project-specific by default) under
+# `## /aw-spec-foundation-backend` and `## /aw-spec-foundation-frontend`, and load
+# through tech-select.
 #
 # Launch via the parametric skill:  /appweaver foundation [strategy]
-#   Interactive (no args): ASKS which lane to scaffold, LISTS the foundations available
-#   for that lane's ecosystem, then ASKS for the app (project) name — all deterministic,
-#   no LLM. Fast path still works:
-#     /appweaver foundation agent VerticalSlice AppWeaver.Health
+#   Fast path: /appweaver foundation agent VerticalSlice AppWeaver.Health
+#   — the name preselects its entry in whichever lane lists it; the app name is used for
+#   every lane. There is no output-directory argument.
 #
 # Headless:
 #   python3 .appweaver/orchestrator/orchestrator.py \
@@ -42,14 +52,14 @@
 # =============================================================================
 
 name: aw-spec-foundation
-description: Scaffold a complete, compiling project INTO A DECLARED LANE — pick the lane, pick from the foundation bundles available for its ecosystem, enter the app name, and the verified bundle is unpacked into that lane's source path with its sentinel renamed. Selection is zero-LLM (list + pick + ask).
-version: 1.2.0
+description: Scaffold every declared lane in one run — backend, then frontend. A lane that already has files is asked whether to overwrite them first (no = skip that lane). For each lane pick a verified pack (unpacked into its lane root folder, sentinel renamed), a spec the agent builds the project from (a bundled *.spec.txt or one you give), or skip it. Spec builds follow the technical rules mapped under /aw-spec-foundation-backend and /aw-spec-foundation-frontend.
+version: 2.0.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
 inputs:
   user_input:
-    description: "Optional fast path: FoundationName [AppName]. Omit to pick a foundation from the list and be asked for the app name. There is no output-directory argument — the scaffold goes into the chosen lane's source path."
+    description: "Optional fast path: FoundationName [AppName]. The name preselects that pack or spec in the lane that lists it; the app name is used for every lane. Omit to pick per lane and be asked for the app name once."
     required: false
     bind: USER_INPUT
 
@@ -62,25 +72,52 @@ standards:
   - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
 
 vars:
-  overwrite: "no"        # flipped by ask_overwrite only when the dry run finds collisions
-  ref_written: "0"       # stays 0 when the reference sample is declined
-  stash_found: "false"   # true only when the reference flow stashed a DbContext
-  app: ""                # resolved app name: fast-path 2nd token, else the ask below
-  app_typed: ""          # app name entered interactively (empty on the fast path)
+  app: ""                # resolved app name: fast-path 2nd token, else asked by the first lane that needs it
+  app_typed: ""          # app name entered interactively
   out_ok: "true"         # cleared when a third fast-path token names an output directory
+  be_status: "not run"
+  be_route: ""
+  be_name: ""
+  be_spec: ""
+  be_files: ""
+  fe_status: "not run"
+  fe_route: ""
+  fe_name: ""
+  fe_spec: ""
+  fe_files: ""
 
 workflow:
 
-  # 0a. THE LANE MODEL, which is where this scaffold is going. Read-only: select-stack is
-  #     the sole writer, and a scaffold has no business declaring the lane it fills.
+  # 0a. THE LANE MODEL. Read-only: select-stack is the sole writer, and a scaffold has no
+  #     business declaring the lane it fills. Both kinds come back flattened
+  #     (backend_* / frontend_*), so one call feeds both sections below.
   - id: lanes
     action: execute_script
     on_error: continue    # never crash raw on an absent stacks.json — the gate explains it
     script: { ref: actions }
     subcommand: lane-resolve
     outputs:
-      - { name: lane_options, from: "$.lane_options" }
-      - { name: lane_count,   from: "$.lane_count" }
+      - { name: lane_options,          from: "$.lane_options" }
+      - { name: backend_declared,      from: "$.backend_declared" }
+      - { name: backend_lane_id,       from: "$.backend_lane_id" }
+      - { name: backend_profile,       from: "$.backend_profile" }
+      - { name: backend_title,         from: "$.backend_title" }
+      - { name: backend_language,      from: "$.backend_language" }
+      - { name: backend_ecosystem,     from: "$.backend_ecosystem" }
+      - { name: backend_source_path,   from: "$.backend_source_path" }
+      - { name: backend_test_path,     from: "$.backend_test_path" }
+      - { name: backend_workdir,       from: "$.backend_workdir" }
+      - { name: backend_build,         from: "$.backend_build" }
+      - { name: frontend_declared,     from: "$.frontend_declared" }
+      - { name: frontend_lane_id,      from: "$.frontend_lane_id" }
+      - { name: frontend_profile,      from: "$.frontend_profile" }
+      - { name: frontend_title,        from: "$.frontend_title" }
+      - { name: frontend_language,     from: "$.frontend_language" }
+      - { name: frontend_ecosystem,    from: "$.frontend_ecosystem" }
+      - { name: frontend_source_path,  from: "$.frontend_source_path" }
+      - { name: frontend_test_path,    from: "$.frontend_test_path" }
+      - { name: frontend_workdir,      from: "$.frontend_workdir" }
+      - { name: frontend_build,        from: "$.frontend_build" }
 
   - id: require_lanes
     action: verify_context
@@ -88,74 +125,27 @@ workflow:
     on_empty: stop
     on_empty_message: >
       /appweaver foundation cannot run: no lane is declared in .appweaver/stacks.json.
-      A scaffold is unpacked into the SOURCE PATH of the lane it belongs to — that is what
-      keeps a project's files inside the subtree every later phase compiles, tests and
-      generates into — so there has to be a lane to scaffold before there is a scaffold.
-      Run /appweaver select-stack first: it declares each lane's stack and source path, and
-      is the first command of both the greenfield and the brownfield sequence.
-
-  # 0b. WHICH lane. One bundle is one lane's project, so a fullstack repo runs this once
-  #     per lane rather than unpacking a tree that spans both. A single declared lane
-  #     auto-confirms; the option carries its own explanation and resolves below.
-  - id: pick_lane
-    action: user_select
-    prompt: "Which lane is this scaffold for? The bundle is unpacked into that lane's source path, and its tests into the lane's test path — nothing lands outside them. Scaffold the other lane by running /appweaver foundation again."
-    options_from_variable: lane_options
-    single_option_confirm: true
-    outputs:
-      - { name: chosen_lane, from: selection }
-
-  # 0c. Resolve the chosen lane to the two paths this run writes into, plus the ecosystem
-  #     that narrows the bundle list. `lane-resolve` strips the option's label itself, so
-  #     the selection goes back in as the id it already carries.
-  - id: lane_target
-    action: execute_script
-    script: { ref: actions }
-    subcommand: lane-resolve
-    args: ["--id", "{{chosen_lane}}"]
-    outputs:
-      - { name: lane_found,     from: "$.found" }
-      - { name: lane_id,        from: "$.lane_id" }
-      - { name: lane_root,      from: "$.source_path" }
-      - { name: lane_test_path, from: "$.test_path" }
-      - { name: lane_ecosystem, from: "$.ecosystem" }
-      - { name: lane_language,  from: "$.language" }
-
-  - id: lane_resolved
-    action: verify_context
-    require_true: lane_found
-    on_false: stop
-    on_false_message: "No lane matches the selection `{{chosen_lane}}` in .appweaver/stacks.json. Re-run /appweaver select-stack to re-declare the lanes, then re-run foundation."
-
-  - id: lane_has_root
-    action: verify_context
-    require_non_empty: lane_root
-    on_empty: stop
-    on_empty_message: "Lane `{{lane_id}}` declares no source path in .appweaver/stacks.json, and the source path is where this scaffold is unpacked. Re-run /appweaver select-stack and give the lane the directory it owns."
-
-  # 1a. LIST the foundations available for THAT LANE's ecosystem (deterministic
-  #     foundations/<ecosystem>/<Name>/<Name>.pack.txt scan — no LLM). A bundle is a whole
-  #     compiling project in one ecosystem's build system, so a Node UI lane is not offered
-  #     a .NET bundle even in a repo that also declares a .NET service; `all_foundations`
-  #     keeps the unfiltered set for the gate message below. A direct "Foundation App"
-  #     argument is parsed here too as an optional fast path.
-  - id: list_foundations
+      A scaffold goes into the LANE ROOT FOLDER of the lane it belongs to — that is what keeps a
+      project's files inside the subtree every later phase compiles, tests and generates
+      into — so there has to be a lane before there is a scaffold. Run
+      /appweaver select-stack first: it declares each lane's stack and lane root folder, and is
+      the first command of both the greenfield and the brownfield sequence.
+
+  # 0b. The fast path, parsed once for the whole run: the app name it carries applies to
+  #     every lane. --ecosystem "" filters the listing to nothing — only the parse is wanted.
+  - id: parse_args
     action: execute_script
     script: { ref: actions }
     subcommand: foundation-list
-    args: ["--args", "{{USER_INPUT}}", "--ecosystem", "{{lane_ecosystem}}"]
+    args: ["--args", "{{USER_INPUT}}", "--ecosystem", ""]
     outputs:
-      - { name: foundations,      from: "$.foundations" }
-      - { name: foundation_count, from: "$.count" }
-      - { name: all_foundations,  from: "$.all_foundations" }
-      - { name: lane_ecosystems,  from: "$.lane_ecosystems" }
-      - { name: preselect_name,   from: "$.preselect_name" }
-      - { name: preselect_app,    from: "$.preselect_app" }
-      - { name: rejected_out,     from: "$.rejected_out" }
+      - { name: preselect_name, from: "$.preselect_name" }
+      - { name: preselect_app,  from: "$.preselect_app" }
+      - { name: rejected_out,   from: "$.rejected_out" }
 
-  # 1b. A third fast-path token used to be an output directory. Refused by name rather
-  #     than ignored: silently dropping a path argument is how someone believes they
-  #     scaffolded a sandbox and finds they filled their service lane.
+  # A third fast-path token used to be an output directory. Refused by name rather than
+  # ignored: silently dropping a path argument is how someone believes they scaffolded a
+  # sandbox and finds they filled their service lane.
   - id: out_dir_given
     action: set
     condition: "{{rejected_out}} != "
@@ -167,207 +157,96 @@ workflow:
     on_false: stop
     on_false_message: >
       `{{rejected_out}}` was given as an output directory, and foundation has none to give.
-      A scaffold is unpacked into the source path of the lane it is for — here lane
-      `{{lane_id}}` at `{{lane_root}}` — so that everything it writes is inside the subtree
-      that lane owns. Re-run as `/appweaver foundation {{preselect_name}} {{preselect_app}}`.
-      To scaffold somewhere else, declare a lane there with /appweaver select-stack and
-      pick that lane.
+      Each lane is scaffolded into its own lane root folder from .appweaver/stacks.json, so that
+      everything written is inside the subtree that lane owns. Re-run without it. To
+      scaffold somewhere else, declare a lane there with /appweaver select-stack.
 
-  - id: have_foundations
-    action: verify_context
-    require_non_empty: foundations
-    on_empty: stop
-    on_empty_message: >
-      No foundation bundle ships for the `{{lane_id}}` lane's ecosystem ({{lane_ecosystem}}).
-      Bundles present: {{all_foundations}}. A foundation is a complete project in one
-      ecosystem's languages and build system, so one from another ecosystem is not a
-      scaffold for this lane — it is a second, foreign project inside it. Either add a
-      bundle under foundations/{{lane_ecosystem}}/<Name>/<Name>.pack.txt (see the pack
-      scripts in that directory), or scaffold `{{lane_root}}` with the stack's own tooling
-      (Spring Initializr, `npm create`, `cargo new`, …) — implement generates INTO a
-      project tree and does not require that the kit be the thing that created it.
-
-  # 1b. PICK the foundation. A matching fast-path arg auto-selects; a lone
-  #     foundation auto-confirms; otherwise the user chooses from the list.
-  - id: pick_foundation
-    action: user_select
-    prompt: "Select a foundation to scaffold from:"
-    options_from_variable: foundations
-    preselect_from: preselect_name
-    single_option_confirm: true
-    outputs:
-      - { name: fname, from: selection }
-
-  # 1c. ASK for the app (project) name — deterministic free-text, no LLM. Skipped
-  #     when the fast-path arg already supplied it (preselect_app non-empty).
-  - id: ask_app
-    action: ask
-    condition: "{{preselect_app}} == "
-    prompt: >
-      Enter the project (application) name — it replaces the foundation's sentinel
-      across the generated tree (dotted / underscored / hyphen / lower forms),
-      e.g. AppWeaver.Health:
-    answer_var: app_typed
-
-  # 1d. Coalesce the app name (engine has no compound conditions → two ordered
-  #     sets): default to the typed answer, then override with the fast-path token.
-  - id: app_from_typed
-    action: set
-    vars: { app: "{{app_typed}}" }
   - id: app_from_arg
     action: set
     condition: "{{preselect_app}} != "
     vars: { app: "{{preselect_app}}" }
 
-  # 1e. Locate the bundle/unpacker for the CHOSEN foundation + read the (bounded)
-  #     pack header (sentinel + file_count shown in the confirm below).
-  - id: locate
-    action: execute_script
-    script: { ref: actions }
-    subcommand: foundation-locate
-    args: ["--name", "{{fname}}", "--app", "{{app}}", "--out", "{{lane_root}}"]
-    outputs:
-      - { name: locate_ok,  from: "$.ok" }
-      - { name: locate_msg, from: "$.reason" }
-      - { name: available,  from: "$.available" }
-      - { name: fname,      from: "$.name" }
-      - { name: app,        from: "$.app" }
-      - { name: sentinel,   from: "$.sentinel" }
-      - { name: file_count, from: "$.file_count" }
-
-  - id: locate_gate
-    action: verify_context
-    require_true: locate_ok
-    on_false: stop
-    on_false_message: "{{locate_msg}}  (available foundations: {{available}})"
-
-  # 2. Confirm the scaffold plan (checkpoint kind 'ask' under every strategy).
-  - id: confirm
-    action: ask
-    prompt: |
-      Foundation: {{fname}} (sentinel {{sentinel}}, {{file_count}} files)
-      App Name:   {{app}}
-      Lane:       {{lane_id}} — {{lane_language}} ({{lane_ecosystem}})
-      Source:     {{lane_root}}          <- the whole bundle unpacks here
-      Tests:      {{lane_test_path}}     <- a test tree the bundle carries is lifted here
-      Rename {{sentinel}} -> {{app}} (dotted/underscored/hyphen/lower forms).
-      Unchanged: 'Projects' sample domain + AppWeaver.* framework packages. Proceed?
-    options: ["yes", "no"]
-    answer_var: proceed
-
-  - id: confirm_gate
-    action: verify_context
-    require_value: proceed
-    equals: "yes"
-    on_mismatch: stop
-    on_mismatch_message: "Cancelled by user."
-
-  # 3. Dry-run to surface collisions, then confirm overwrite if needed.
-  - id: dry_run
-    action: execute_script
-    script: { ref: actions }
-    subcommand: foundation-unpack
-    args: ["--name", "{{fname}}", "--app", "{{app}}", "--out", "{{lane_root}}", "--dry-run"]
-    outputs:
-      - { name: has_collisions, from: "$.has_collisions" }
-
-  - id: ask_overwrite
-    action: ask
-    condition: "{{has_collisions}} == true"
-    prompt: "Output files already exist. Overwrite them?"
-    options: ["yes", "no"]
-    answer_var: overwrite
-
-  - id: overwrite_gate
-    action: verify_context
-    condition: "{{has_collisions}} == true"
-    require_value: overwrite
-    equals: "yes"
-    on_mismatch: stop
-    on_mismatch_message: "Aborted — output files exist and overwrite was declined."
-
-  # 4. Unpack for real.
-  - id: unpack
-    action: execute_script
-    script: { ref: actions }
-    subcommand: foundation-unpack
-    args: ["--name", "{{fname}}", "--app", "{{app}}", "--out", "{{lane_root}}", "--test-path", "{{lane_test_path}}", "--force", "{{overwrite}}"]
-    outputs:
-      - { name: written,       from: "$.written" }
-      - { name: tests_moved,   from: "$.tests_moved" }
-      - { name: tests_message, from: "$.tests_message" }
-
-  # 5. Optional reference sample.
-  - id: ask_reference
-    action: ask
-    prompt: "Include the reference sample project (Projects, Users, Reports slices)?"
-    options: ["yes", "no"]
-    answer_var: want_reference
-
-  - id: stash_dbcontext
-    action: execute_script
-    condition: "{{want_reference}} == yes"
-    script: { ref: actions }
-    subcommand: foundation-stash-dbcontext
-    args: ["--out", "{{lane_root}}"]
-    outputs:
-      - { name: stash_found, from: "$.found" }
-      - { name: db_context,  from: "$.dbcontext" }
-      - { name: db_backup,   from: "$.backup" }
-
-  - id: reference_unpack
-    action: execute_script
-    condition: "{{want_reference}} == yes"
-    script: { ref: actions }
-    subcommand: foundation-unpack
-    args: ["--name", "{{fname}}", "--app", "{{app}}", "--out", "{{lane_root}}", "--test-path", "{{lane_test_path}}", "--reference"]
-    outputs:
-      - { name: ref_written, from: "$.written" }
-
-  # 6. Merge the foundation DbContext (usings + DbSet<>) back over the reference
-  #    one. agent_author: read-only generation, the ENGINE writes the target.
-  - id: merge_dbcontext
-    action: agent_author
-    condition: "{{stash_found}} == true"
-    context: ["{{db_backup}}", "{{db_context}}"]
-    include_standards: false
-    task: |
-      The target file ({{db_context}}) currently holds the REFERENCE DbContext
-      (sample DbSet<> properties, no OnModelCreating). The backup ({{db_backup}})
-      holds the FOUNDATION DbContext (full OnModelCreating, no DbSet<>). Produce a
-      single merged ApplicationDbContext:
-        - Base = the FOUNDATION file (backup).
-        - Add any `using` directives from the reference that are missing.
-        - Insert every reference `public DbSet<…>` line as a block right after the
-          class opening brace (before OnModelCreating), preserving any comment above them.
-        - Keep everything else in the foundation file unchanged.
-    output_target: { type: file, path: "{{db_context}}" }
-
-  # 7. Verify (sentinel residue must be zero in the generated tree).
-  - id: verify
-    action: execute_script
-    script: { ref: actions }
-    subcommand: foundation-verify
-    args: ["--out", "{{lane_root}}", "--sentinel", "{{sentinel}}"]
-    outputs:
-      - { name: clean,   from: "$.clean" }
-      - { name: residue, from: "$.residue" }
+  # 1. BACKEND. Not declared -> say so and move on to the frontend.
+  - id: backend_absent
+    action: set
+    condition: "{{backend_declared}} != true"
+    vars:
+      be_status: "no backend lane is declared in .appweaver/stacks.json — nothing scaffolded for a service; run /appweaver select-stack to add one"
+
+  - id: backend
+    action: include
+    condition: "{{backend_declared}} == true"
+    module: .appweaver/orchestrator/modules/foundation-lane.orch.yaml
+    with:
+      fl_kind: "backend"
+      fl_lane_id: "{{backend_lane_id}}"
+      fl_profile: "{{backend_profile}}"
+      fl_title: "{{backend_title}}"
+      fl_language: "{{backend_language}}"
+      fl_ecosystem: "{{backend_ecosystem}}"
+      fl_source_path: "{{backend_source_path}}"
+      fl_test_path: "{{backend_test_path}}"
+      fl_workdir: "{{backend_workdir}}"
+      fl_build: "{{backend_build}}"
+
+  - id: backend_result
+    action: set
+    condition: "{{backend_declared}} == true"
+    vars:
+      be_status: "{{fl_status}}"
+      be_route: "{{fl_route}}"
+      be_name: "{{fl_name}}"
+      be_spec: "{{fl_spec_path}}"
+      be_files: "{{fl_files}}"
+
+  # 2. FRONTEND. Not declared -> say so; the run ends after this section either way.
+  - id: frontend_absent
+    action: set
+    condition: "{{frontend_declared}} != true"
+    vars:
+      fe_status: "no frontend lane is declared in .appweaver/stacks.json — nothing scaffolded for a UI; run /appweaver select-stack to add one"
+
+  - id: frontend
+    action: include
+    condition: "{{frontend_declared}} == true"
+    module: .appweaver/orchestrator/modules/foundation-lane.orch.yaml
+    with:
+      fl_kind: "frontend"
+      fl_lane_id: "{{frontend_lane_id}}"
+      fl_profile: "{{frontend_profile}}"
+      fl_title: "{{frontend_title}}"
+      fl_language: "{{frontend_language}}"
+      fl_ecosystem: "{{frontend_ecosystem}}"
+      fl_source_path: "{{frontend_source_path}}"
+      fl_test_path: "{{frontend_test_path}}"
+      fl_workdir: "{{frontend_workdir}}"
+      fl_build: "{{frontend_build}}"
+
+  - id: frontend_result
+    action: set
+    condition: "{{frontend_declared}} == true"
+    vars:
+      fe_status: "{{fl_status}}"
+      fe_route: "{{fl_route}}"
+      fe_name: "{{fl_name}}"
+      fe_spec: "{{fl_spec_path}}"
+      fe_files: "{{fl_files}}"
 
 outputs:
-  foundation: "{{fname}}"
+  backend: "{{be_status}}"
+  frontend: "{{fe_status}}"
   app: "{{app}}"
-  lane: "{{lane_id}}"
-  source_path: "{{lane_root}}"
-  test_path: "{{lane_test_path}}"
-  files_written: "{{written}}"
-  tests_moved: "{{tests_moved}}"
-  tests_note: "{{tests_message}}"
-  reference_files: "{{ref_written}}"
-  sentinel_clean: "{{clean}}"
-  sentinel_residue: "{{residue}}"
-  note: "Foundation scaffolded into the {{lane_id}} lane at {{lane_root}} ({{written}} file(s), sentinel renamed to {{app}}); {{tests_message}}. Everything written is inside the subtree that lane owns, which is where implement generates and build/test/run act. Configure your AppWeaver.* NuGet feed and run the AppHost to confirm the scaffold starts before building on it."
+  backend_route: "{{be_route}}"
+  backend_foundation: "{{be_name}}"
+  backend_spec: "{{be_spec}}"
+  backend_files: "{{be_files}}"
+  frontend_route: "{{fe_route}}"
+  frontend_foundation: "{{fe_name}}"
+  frontend_spec: "{{fe_spec}}"
+  frontend_files: "{{fe_files}}"
+  note: "Each lane line above says what was scaffolded into it, or why nothing was. Everything written is inside the lane that owns it, which is where implement generates and build/test/run act. A spec build's spec is kept at .appweaver/foundation/<lane>.spec.md. Run /appweaver foundation again to scaffold a lane that was skipped — answer no to the overwrite question for the lane that is already done."
   # constitution is named here because specify declares constitution.domain.md a
   # REQUIRED context file. It announces rather than stops when the file is absent,
   # so a sequence that skips this step produces a spec authored with no domain
   # frame and only a [context] MISSING line to show for it.
-  next: "Another lane still to scaffold? Run /appweaver foundation again and pick it — one bundle fills one lane. Otherwise carry on with /appweaver select-domain → constitution → select-feature → specify. select-domain binds this workspace to a governed project under guardrails/projects/ and is one-time; skip it only where no such project exists. /appweaver constitution is NOT optional — it authors the constitution halves, and specify declares constitution.domain.md as REQUIRED context while plan and implement read constitution.technical.md (plus constitution.ui.md on a frontend lane); it also needs the lane declaration select-stack wrote, which is why it runs after this. /appweaver select-feature then picks the feature to build — every stage from specify onward reads that active feature and stops without it."
+  next: "/appweaver constitution → specify. /appweaver constitution is NOT optional — it authors the constitution halves, and specify declares constitution.domain.md as REQUIRED context while plan and implement read constitution.technical.md (plus constitution.ui.md on a frontend lane); it reads the domain rule map of the project .appweaver/domain.json names (guardrails/project-specific/ by default). On a project with no specs yet, constitution also creates the default bounded context MainContext and its feature CoreFeature and makes both active, so specify can run straight after it; to use your own names, run /appweaver select-bounded-context <Name> and then /appweaver select-feature <Name> before specify. Every stage from specify onward reads the active feature and stops without it, and once any bounded context exists select-feature refuses to run until one is selected."