aw-spec-cli 0.1.8 → 0.1.9

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

@@ -0,0 +1,293 @@
+# =============================================================================
+# aw-spec-parity (orchestrator) — the CUTOVER GATE of the Brownfield Pipeline
+#
+# The migration-grade oracle. Once a slice has a new (candidate) implementation
+# (forward pipeline) and a green characterization fence, PARITY runs every case
+# in a manifest against BOTH the running LEGACY system and the new CANDIDATE and
+# diffs observable output (response status + body, and optional resulting-state
+# probes). The seam cuts over to the candidate ONLY when parity HOLDS — the
+# running legacy system is the oracle, not a written spec.
+#
+#   inventory → adopt → characterize → [ forward pipeline ] → PARITY → cutover   ← you are here
+#
+# Parity is what analyze-slice/characterize can't be: it compares against a LIVE oracle,
+# so it catches behaviour no static test captured. Approved intended differences
+# are whitelisted in the manifest's `expected_deviations` — and each MUST be
+# recorded as a MODIFIED spec item via the CR loop, so behaviour never drifts
+# silently.
+#
+# Two things the operator supplies (the pipeline cannot guess them): WHERE the
+# legacy and candidate systems are running (the two `sides` in the manifest).
+# parity AUTHORS the input corpus from the spec + source-map, then STOPS for you
+# to fill the endpoints, then diffs on re-run.
+#
+# On a mismatch: triage — a REGRESSION is fixed in the CANDIDATE code (to match
+# legacy); an INTENDED difference is added to expected_deviations (+ recorded as a
+# MODIFIED spec item via /appweaver specify). parity never changes the spec here and
+# never forces a match by breaking the candidate.
+#
+# Launch:  /appweaver parity [strategy] [focus/guidance]
+# Prereq:  /appweaver adopt (spec.md + design.md + source-map.md) + a running
+#          candidate, and the legacy system reachable.
+# =============================================================================
+
+name: aw-spec-parity
+description: Run a parity manifest's cases against the running legacy system and the new candidate, diff observable output, and gate cutover on parity holding. Authors the corpus from the spec + source-map; the operator supplies the two endpoints. Mismatches are triaged (fix the candidate, or whitelist an intended deviation that must become a MODIFIED spec item). The live legacy system is the oracle.
+version: 1.0.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: Optional focus / guidance (an area or extra input cases to cover).
+    required: false
+    bind: USER_INPUT
+
+scripts:
+  parity:
+    sh:  .appweaver/scripts/bash/aw-parity.sh
+    ps1: .appweaver/scripts/powershell/aw-parity.ps1
+  actions:
+    sh:  .appweaver/scripts/bash/aw-spec-actions.sh
+    ps1: .appweaver/scripts/powershell/aw-spec-actions.ps1
+
+# Sticky standards seed = the UNIVERSAL always-on rule only (ai-rules). The code-generation
+# set (triage may fix the CANDIDATE code to match legacy) is no longer hardcoded here — it is
+# now CONFIGURATION, loaded per-command from guardrails/projects/<project>/tech-rule-bindings.md
+# under "## /aw-spec-parity" by the tech-select module (see the tech_select step below). No
+# domain files: the target behaviour is defined by the running legacy system, not domain rules —
+# the tech map lists only technical files. (parity does not reference constitution.technical.md.)
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+vars:
+  parity_ok: "false"
+  case_count: "0"
+  sides_configured: "false"
+
+workflow:
+
+  # 0. TECHNICAL rule files → sticky standards (configuration, not hardcoded). tech-select
+  #    reads guardrails/projects/<project>/tech-rule-bindings.md under "## /aw-spec-parity" and
+  #    loads that code-generation set into the sticky standards the agent_generate triage step
+  #    ALWAYS prepends. No domain rule file is loaded here — the tech map lists only technical
+  #    files. No blocking gate: an unconfigured project soft-continues (the target behaviour is
+  #    the running legacy system, not any rule file).
+  - id: tech_select
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-parity }
+
+  # 1. Resolve the feature + require the adopted artifacts (spec/design/source-map).
+  - id: feature_paths
+    action: execute_script
+    on_error: continue      # never crash raw on 'no feature set' — the gate below explains it
+    script: { ref: actions }
+    subcommand: feature-paths
+    outputs:
+      - { name: feature_dir,   from: "$.feature_dir" }
+      - { name: spec_file,     from: "$.spec_file" }
+      - { name: design_file,   from: "$.design_file" }
+      - { name: spec_exists,   from: "$.spec_exists" }
+      - { name: design_exists, from: "$.design_exists" }
+
+  - id: require_feature
+    action: verify_context
+    require_non_empty: feature_dir
+    on_empty: stop
+    on_empty_message: "No active feature. Run /appweaver select-feature first (pick or create the aggregate, e.g. Order), then re-run parity."
+
+  - id: verify_spec
+    action: verify_context
+    require_true: spec_exists
+    on_false: stop
+    on_false_message: "No spec.md for the current feature. Adopt the slice first: /appweaver adopt <Aggregate>."
+
+  - id: verify_design
+    action: verify_context
+    require_true: design_exists
+    on_false: stop
+    on_false_message: "No design.md for the current feature. Run /appweaver adopt <Aggregate> (or /appweaver design) first."
+
+  - id: set_source_map
+    action: set
+    vars:
+      source_map: "{{feature_dir}}/source-map.md"
+  # required_files raises a fixed Stop naming the missing file → run adopt first.
+  - id: require_source_map
+    action: verify_context
+    required_files: ["{{source_map}}"]
+
+  # 2. Scaffold the parity manifest (idempotent — keeps an existing one, incl. the
+  #    operator's endpoints and any cases already authored).
+  - id: scaffold_parity
+    action: execute_script
+    script: { ref: parity }
+    subcommand: scaffold
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: manifest_path, from: "$.manifest_path" }
+
+  # 3. Read current manifest readiness BEFORE authoring, so cases are only authored
+  #    once (a re-run after the operator fills endpoints skips authoring).
+  - id: check_initial
+    action: execute_script
+    script: { ref: parity }
+    subcommand: check
+    args: ["--manifest", "{{manifest_path}}"]
+    outputs:
+      - { name: case_count,       from: "$.case_count" }
+      - { name: sides_configured, from: "$.sides_configured" }
+
+  # 4. Pre-execution hooks.
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_parity"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # 5. AUTHOR the parity corpus (only when no real cases exist yet). Derive cases
+  #    from the spec's US/FR and the source-map's as-built quirks. Edits ONLY the
+  #    `cases` array — the operator owns `sides`.
+  - id: ctx_author_cases
+    condition: "{{case_count}} == 0"
+    action: build_context
+    context:
+      - { path: "{{manifest_path}}" }             # the manifest to edit (cases only)
+      - { path: "{{spec_file}}" }                 # US / FR / SC — the observable surface
+      - { path: "{{source_map}}" }                # as-built quirks (each MUST get a case)
+      - { path: "{{design_file}}" }               # endpoints / handlers / events
+  - id: author_cases
+    condition: "{{case_count}} == 0"
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      Author the PARITY CORPUS by editing the `cases` array of the parity manifest
+      (in context) — the inputs whose outputs must match between the running legacy
+      system and the new candidate. Guidance: {{USER_INPUT}}
+      Rules:
+      - Derive cases from the spec's User Stories / FR / Success Criteria (in context)
+        and the design's endpoints/handlers: one case per observable behaviour, with
+        representative inputs — the happy path, boundaries, and error paths.
+      - Every AS-BUILT QUIRK recorded in source-map.md (in context) MUST get a case
+        that will confirm the candidate REPRODUCES it (parity fails if the new code
+        "fixes" a quirk that was not turned into an intended deviation).
+      - Each case: a stable `id` (PC-002, PC-003, …), a `description`, `spec_ids`, a
+        `request` (method/path/headers/body — compared on status + body), and — where
+        resulting STATE matters — an optional `state_probe` request (a follow-up
+        read compared on body). Use the routes/fields the design + code actually use.
+      - Edit ONLY the `cases` array. Preserve `sides`, `compare`, `expected_deviations`
+        and every other key BYTE-FOR-BYTE (the operator owns the two `sides`
+        endpoints). Remove the PC-001-EXAMPLE placeholder. Emit VALID JSON.
+    outputs:
+      - { name: authored, from: "$.files" }
+
+  # 6. Re-read readiness after authoring.
+  - id: check_ready
+    action: execute_script
+    script: { ref: parity }
+    subcommand: check
+    args: ["--manifest", "{{manifest_path}}"]
+    outputs:
+      - { name: case_count,       from: "$.case_count" }
+      - { name: sides_configured, from: "$.sides_configured" }
+      - { name: check_error,      from: "$.error" }
+
+  - id: cases_gate
+    action: verify_context
+    require_true: case_count
+    on_false: stop
+    on_false_message: "No parity cases in {{manifest_path}} (check error: {{check_error}}). Authoring produced none or the JSON is invalid — add cases by hand (derived from the spec + source-map) and re-run."
+
+  # 7. OPERATOR HANDOFF: the two `sides` endpoints cannot be guessed. Stop here until
+  #    they are filled (where the legacy + candidate systems are running).
+  - id: sides_gate
+    action: verify_context
+    require_true: sides_configured
+    on_false: stop
+    on_false_message: "Parity corpus is ready ({{case_count}} case(s)), but the endpoints are not set. Edit {{manifest_path}} → set sides.legacy and sides.candidate to where your LEGACY and NEW systems are running (kind:http base_url, or kind:shell command), then re-run /appweaver parity."
+
+  # 8. PARITY + TRIAGE loop: run both sides + diff; on mismatch, fix the CANDIDATE
+  #    (regression) or whitelist an INTENDED deviation, then re-run. Bounded (3×).
+  - id: parity_loop
+    action: loop
+    while: "{{parity_ok}} != true"
+    max_iterations: 3
+    steps:
+      - id: run_parity
+        action: execute_script
+        on_error: continue
+        script: { ref: parity }
+        subcommand: run
+        args: ["--manifest", "{{manifest_path}}"]
+        outputs:
+          - { name: parity_ok,   from: "$.ok" }
+          - { name: mismatched,  from: "$.mismatched" }
+          - { name: matched,     from: "$.matched" }
+          - { name: par_errors,  from: "$.errors" }
+          - { name: report_path, from: "$.report_path" }
+      - id: hold_break
+        action: break
+        condition: "{{parity_ok}} == true"
+      - id: ctx_triage
+        action: build_context
+        context:
+          - { path: "{{report_path}}" }           # the unaccepted diffs + accepted deviations
+          - { path: "{{manifest_path}}" }         # to add expected_deviations
+          - { path: "{{spec_file}}" }
+          - { path: "{{source_map}}" }
+      - id: triage
+        action: agent_generate
+        tools: "Read,Write,Edit,Bash"
+        permission_mode: acceptEdits
+        task: |
+          Parity did not hold. Triage EACH unaccepted diff in the report (in context)
+          — the LEGACY output is the oracle:
+          - REGRESSION (the candidate is wrong): fix the CANDIDATE (new) code so its
+            observable output matches legacy. Read the candidate code, correct it, and
+            keep behaviour aligned with the legacy value shown in the report. Never
+            change the legacy side, and never edit a test just to hide the diff.
+          - INTENDED difference (a deliberate modernization): add an entry to the
+            manifest's `expected_deviations` ({case, path, reason}) so parity accepts
+            it — AND state in the reason that it must be recorded as a MODIFIED spec
+            item via /appweaver specify (do NOT edit spec.md here, and do NOT change code
+            to force a match). An as-built quirk the candidate dropped is a REGRESSION
+            unless it is a reviewed intended change.
+          - INVOKE ERROR (a side unreachable / bad request): report it — the operator
+            must make both systems reachable / fix the case; do not fake a pass.
+          Change ONLY candidate code and/or the manifest's expected_deviations.
+          Report:
+          {{report_path}}
+        outputs:
+          - { name: triaged_files, from: "$.files" }
+
+  - id: parity_gate
+    action: verify_context
+    require_true: parity_ok
+    on_false: stop
+    on_false_message: "Parity does NOT hold after 3 attempts ({{mismatched}} mismatch(es), {{par_errors}} error(s)). See {{report_path}}. Resolve each unaccepted diff — fix the candidate to match legacy, or whitelist an intended deviation (and record it as a MODIFIED spec item via /appweaver specify) — then re-run. Do NOT cut over until parity holds."
+
+  # 9. Post-execution hooks.
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_parity"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  feature_dir: "{{feature_dir}}"
+  manifest_path: "{{manifest_path}}"
+  report_path: "{{report_path}}"
+  matched: "{{matched}}"
+  next: "PARITY HOLDS — the slice is cutover-ready. Route the seam to the candidate (Run/Deploy); the legacy path goes dark and roll back = re-route. Fold every accepted deviation into spec.md as a MODIFIED item via /appweaver specify. Repeat inventory→adopt→characterize→parity for the next slice."

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

@@ -0,0 +1,194 @@
+# =============================================================================
+# aw-spec-run (orchestrator) — migrate + prepare to run
+#
+# Apply database migrations; on failure fix (up to 3×) and record the touched files
+# in the slice's OKF concept; then surface the launch command. A live server is not
+# held by the batch engine — the launch hint is reported for the user/agent to start.
+# Run after /appweaver analyze-slice.
+#
+# 1.1.0 — the fix loop's file list now comes from the OKF concept's `source_files`
+# (`aw-xref concept-paths`) instead of the retired `design-paths` scan for
+# ```lang path=… fences, and the tail step records fix-loop files in that concept
+# instead of copying file bodies back into design fences (`design-reconcile`).
+#
+# Launch:  /appweaver run [strategy]
+# =============================================================================
+
+name: aw-spec-run
+description: Apply migrations, fix migration/runtime errors, record the touched files in the slice's knowledge concept, and report the launch command.
+version: 1.1.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+scripts:
+  actions:
+    sh:  .appweaver/scripts/bash/aw-spec-actions.sh
+    ps1: .appweaver/scripts/powershell/aw-spec-actions.ps1
+  xref:
+    sh:  .appweaver/scripts/bash/aw-xref.sh
+    ps1: .appweaver/scripts/powershell/aw-xref.ps1
+
+# No hardcoded TECHNICAL standards seed — the sticky set carries only the kit's universal
+# operating rules, which is where "never run a migration against a shared environment"
+# lives. The technical rule file
+# the migration step works against (persistence) is now CONFIGURATION, loaded per-command from
+# guardrails/projects/<project>/tech-rule-bindings.md under "## /aw-spec-run" by the tech-select
+# module (see the tech_select step below). No domain files; run does not reference
+# constitution.technical.md. (missing files skipped at assembly time)
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+vars:
+  migrate_ok: "false"
+
+workflow:
+
+  # 0. TECHNICAL rule files → sticky standards (configuration, not hardcoded). tech-select
+  #    reads guardrails/projects/<project>/tech-rule-bindings.md under "## /aw-spec-run" and loads
+  #    that set (persistence) into the sticky standards the agent_generate migration step ALWAYS
+  #    prepends. No domain rule file here. No blocking gate: an unconfigured project soft-continues.
+  - id: tech_select
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-run }
+
+  - id: feature_paths
+    action: execute_script
+    on_error: continue      # never crash raw on 'no feature set' — the gate below explains it
+    script: { ref: actions }
+    subcommand: feature-paths
+    outputs:
+      - { name: feature_dir, from: "$.feature_dir" }
+
+  - id: require_feature
+    action: verify_context
+    require_non_empty: feature_dir
+    on_empty: stop
+    on_empty_message: "No active feature. Run /appweaver select-feature first (pick or create the aggregate, e.g. Order), then re-run run."
+
+  # Require the SERVICE LANE and its source path. Migrations belong to the backend
+  # lane by definition, and run-migrate searches that lane's root for the project
+  # instead of assuming `src/` — which is what lets a repo whose service code sits
+  # in `Legacy/App/` or `backend/` find its own migrations.
+  - id: lane_gate
+    action: include
+    module: .appweaver/orchestrator/modules/lane-gate.orch.yaml
+    with: { require: backend, command: "/appweaver run" }
+
+  # The slice's source files, from its OKF concept — what the migration fix loop below is
+  # handed. Replaces the retired `design-paths` fence scan (the tech-agnostic design.md
+  # carries no ```lang path=… code blocks, so it returned nothing and the fixer got an
+  # EMPTY context). Read-only, exits 0 with paths=[] when there is no concept yet, and
+  # on_error: continue so a missing bundle can never block a migration.
+  - id: concept_paths
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-paths
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: all_paths,     from: "$.paths" }
+      - { name: paths_missing, from: "$.missing" }
+
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_run"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # Migrate → (if red) fix → re-migrate, up to 3×.
+  - id: migrate_loop
+    action: loop
+    while: "{{migrate_ok}} != true"
+    max_iterations: 3
+    steps:
+      - id: migrate
+        action: execute_script
+        on_error: continue
+        script: { ref: actions }
+        subcommand: run-migrate
+        args: ["--feature-dir", "{{feature_dir}}"]
+        outputs:
+          - { name: migrate_ok,   from: "$.ok" }
+          - { name: migrate_tool, from: "$.tool" }
+          - { name: migrate_log,  from: "$.log_tail" }
+      - id: green_break
+        action: break
+        condition: "{{migrate_ok}} == true"
+      - id: ctx_fix
+        action: build_context
+        vars:
+          migrate_log: "{{migrate_log}}"
+        context_from: all_paths
+      - id: fix
+        action: agent_generate
+        tools: "Read,Write,Edit,Bash"
+        permission_mode: acceptEdits
+        task: |
+          A migration/runtime step failed. Fix the migration or configuration in
+          the files in context (usually the Infra layer), preserving intent. Log:
+          {{migrate_log}}
+        outputs:
+          - { name: fixed_files, from: "$.files" }
+
+  - id: run_gate
+    action: verify_context
+    require_true: migrate_ok
+    on_false: stop
+    on_false_message: "Migration still failing after 3 fix attempts. Last log: {{migrate_log}}"
+
+  # Record what the migration fix loop touched in the slice's OKF concept. Replaces the
+  # retired `design-reconcile` (which copied file bodies back into design fences — a
+  # silent no-op since design.md stopped carrying code). The fix loop can CREATE files
+  # (a new migration, a config) that implement never recorded. UNION (--merge), never
+  # replace. Advisory: conditioned + on_error: continue, never gated.
+  - id: okf_merge_run_fixes
+    action: execute_script
+    condition: "{{fixed_files}}"
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{fixed_files}}", "--merge"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
+
+  # Surface the launch command (does not start a long-lived server). The lane's own
+  # `run` is the answer — it is what the profile declares and what `run-phase` would
+  # execute — so the hint is right on every stack instead of on one. find-host-project
+  # still runs because a .NET host directory is worth naming when there is one, but it
+  # is advisory: it locates a Program.cs, so it finds nothing on a Spring or a Go lane
+  # and that is a blank field, not a failure (on_error: continue, no gate).
+  - id: locate_host
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: find-host-project
+    outputs:
+      - { name: host_found,   from: "$.found" }
+      - { name: host_project, from: "$.project_dir" }
+
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_run"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  feature_dir: "{{feature_dir}}"
+  migrate_tool: "{{migrate_tool}}"
+  okf_concept: "{{okf_concept}}"
+  # Declared in the concept but absent on disk — advisory index drift, never gated.
+  stale_source_files: "{{paths_missing}}"
+  host_project: "{{host_project}}"
+  launch_hint: "{{lane_run}}  (the {{lane_id}} lane's declared run command, from .appweaver/stacks.json)"
+  next: "/appweaver deploy"

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

@@ -0,0 +1,83 @@
+# =============================================================================
+# aw-spec-select-domain (orchestrator) — select the active PROJECT under guardrails/projects/
+#
+# The command name and .appweaver/domain.json are historical: what is selected is a
+# project folder, and a project is bound to rules by its two maps, not by an industry.
+#
+# Pure orchestration/governance, NO generation: scripts + one gate + one HITL select.
+# Exercises the D1 interaction channel: under ANY strategy the `user_select`
+# step suspends via --checkpoint (kind 'select') so the LAUNCHING agent asks
+# the user; headless runs prefill with --input, --select select_domain=<name>,
+# or --non-interactive.
+#
+# Run (interactive via launcher):
+#   python3 .appweaver/orchestrator/orchestrator.py \
+#     .appweaver/orchestrator/workflows/aw-spec-select-domain.orch.yaml \
+#     --checkpoint .appweaver/orchestrator/.state/select-domain.state.json --json
+# =============================================================================
+
+name: aw-spec-select-domain
+description: Select the active project under guardrails/projects/ and store it in .appweaver/domain.json, binding both of that project's rule maps — domain-rule-bindings.md and tech-rule-bindings.md — so every AW-Spec command loads the right domain AND technical rule files.
+version: 1.0.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: Optional project folder name under guardrails/projects/ to set directly (e.g. dotnet-default-project). An industry name is not a valid value — an industry is a corpus a project's map points at, never a selection.
+    required: false
+    bind: USER_INPUT
+
+scripts:
+  actions:
+    sh:  .appweaver/scripts/bash/aw-spec-actions.sh
+    ps1: .appweaver/scripts/powershell/aw-spec-actions.ps1
+
+workflow:
+
+  # 1. Discover candidate projects = subdirs of guardrails/projects/ carrying a rule map.
+  - id: list_domains
+    action: execute_script
+    script: { ref: actions }
+    subcommand: list-domains
+    outputs:
+      - { name: domains, from: "$.domains" }
+
+  # 2. Stop early if there are no domains to choose from.
+  - id: guard_no_domains
+    action: verify_context
+    require_non_empty: domains
+    on_empty_message: >
+      No governed projects found. Copy guardrails/projects/dotnet-default-project/ to
+      guardrails/projects/<name>/ and repoint its two maps at the technology and domain
+      corpora this project uses, then re-run.
+    on_empty: stop
+
+  # 3. Choose the domain. If USER_INPUT names a valid domain it is used directly;
+  #    otherwise the launcher relays the choice to the user. One option => confirm.
+  - id: select_domain
+    action: user_select
+    prompt: "Select the active domain:"
+    options_from_variable: domains
+    preselect_from: USER_INPUT     # direct-argument fast path
+    single_option_confirm: true
+    outputs:
+      - { name: chosen, from: selection }
+
+  # 4. Persist the choice to .appweaver/domain.json and report map status.
+  - id: set_domain
+    action: execute_script
+    script: { ref: actions }
+    subcommand: set-domain
+    args: ["--domain", "{{chosen}}"]
+    outputs:
+      - { name: domain,     from: "$.domain" }
+      - { name: map_path,   from: "$.map_path" }
+      - { name: map_exists, from: "$.map_exists" }
+
+outputs:
+  domain: "{{domain}}"
+  domain_rule_bindings: "{{map_path}}"
+  domain_rule_bindings_exists: "{{map_exists}}"
+  note: "Active project '{{domain}}' persisted to .appweaver/domain.json. It selects TWO rule maps under guardrails/projects/{{domain}}/ — domain-rule-bindings.md (DOMAIN rules; read by constitution + specify only, because the spec is the pivot) and tech-rule-bindings.md (TECHNICAL rules; read by 10 workflows incl. design, implement, build and run). The rule FILES themselves live in shared corpora — guardrails/technology/<stack>/ and guardrails/domain/<industry>/ — and the maps are what bind this project to them, so two projects can share a corpus and differ only in their maps and their own three requirements files. domain_rule_bindings_exists reports the domain half only. A map that is absent, or a command with no heading in one, loads nothing for that class and SOFT-CONTINUES — an absent heading is a valid state, never a failure."
+  next: "/appweaver select-feature   (then specify — the per-feature path). Re-run /appweaver select-domain any time to switch projects; it rebinds both maps at once."