aw-spec-cli 0.1.29 → 0.1.31

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

@@ -65,13 +65,20 @@
 # score the WHOLE slice, against masters that carry the change, with the fix loops and the
 # referrer blast radius.
 #
+# THE WORKING LANE. Only the lanes the developer on this machine works on (.appweaver/
+# lane.json — select-stack writes the default, select-lane narrows it) are tested, fixed and
+# scored. A backend developer's gate is not failed by the frontend's tests, its fix loops are
+# never handed the frontend's files, and the composition pass — the service lane's container
+# — runs only for a developer who works on the backend. With the default (every declared
+# lane) every lane is tested, as before.
+#
 # Launch:  /appweaver analyze-slice [strategy]
 # Prereq:  /appweaver build   (compiled code for the active feature).
 # =============================================================================
 
 name: aw-spec-analyze-slice
 description: The design↔code conformance gate — run the slice's tests against its acceptance criteria, check the code against the domain gate overlays AND the bounded context's domain-model.md (every invariant the slice's own aggregate section states must be enforced as written; one another aggregate owns is reported, not blocking), verify the change did not break any referring aggregate (the OKF referrer blast radius) and write a triage report before stopping if it did, refresh + review its OKF concept, and record every fix in it. Sits after finalize-delta on the change path, so the two masters it scores against already carry the change, and before close-delta, so a red gate leaves the change open and recoverable.
-version: 2.6.0
+version: 2.7.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -117,8 +124,13 @@ vars:
   wiring_ok: "true"
   unbound: ""
   be_declared: "false"
+  be_working: "false"       # the backend is a lane this developer works on — .appweaver/lane.json
   be_lane_id: ""
   be_source_path: ""
+  working_lane: ""
+  working_kind: ""          # one kind when the developer works on one lane of two, else empty — every declared lane
+  working_root: ""
+  working_test_path: ""
   wiring_notes: ""
   # The integrity fence blocks through this, not through `integrity_ok` — a fence skipped
   # because there were no tests to run must not read as a broken referrer.
@@ -244,8 +256,24 @@ workflow:
       - { name: active_change, from: "$.active_change" }
       - { name: has_change,    from: "$.has_change" }
 
+  # THE WORKING LANES — which lanes this developer's gate tests, fixes and scores. Read with
+  # --feature-dir, so a lane the feature records no surface in is not worked either.
+  - id: working_lanes
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: lane-resolve
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: working_lane,      from: "$.working_lane" }
+      - { name: working_kind,      from: "$.working_kind" }
+      - { name: working_root,      from: "$.working_root" }
+      - { name: working_test_path, from: "$.working_test_path" }
+      - { name: be_working,        from: "$.backend_working" }
+
   # The slice's source files, from its OKF concept — the context all three passes below
-  # work over (test fix loop, integrity triage, conformance). Replaces the retired
+  # work over (test fix loop, integrity triage, conformance). `--under` keeps the working
+  # lane's own two subtrees when the developer works on one lane of two. Replaces the retired
   # `design-paths` fence scan: backend-plan.md is tech-agnostic prose with no ```lang path=…
   # code blocks, so that scan returned nothing and every pass ran on an EMPTY file list.
   # Read-only, exits 0 with paths=[] when there is no concept yet; on_error: continue so
@@ -255,7 +283,7 @@ workflow:
     on_error: continue
     script: { ref: xref }
     subcommand: concept-paths
-    args: ["--feature-dir", "{{feature_dir}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{working_root}}", "--under", "{{working_test_path}}"]
     outputs:
       - { name: all_paths,     from: "$.paths" }
       - { name: paths_missing, from: "$.missing" }
@@ -287,7 +315,7 @@ workflow:
         # to make tests pass, and it can only repair THIS feature (its design + spec are
         # what is in context) — so referring aggregates are deliberately NOT in this run;
         # they are verified read-only by the integrity gate below.
-        args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice"]
+        args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--kind", "{{working_kind}}"]
         outputs:
           - { name: test_ok,      from: "$.fence_green" }
           - { name: test_tool,    from: "$.tool" }
@@ -527,6 +555,9 @@ workflow:
   # It reads FILES, so the query declares tools — the composition root is shared
   # infrastructure and is often not among the slice's own concept paths. Registration by
   # assembly scan or convention counts; assuming one without finding it does not.
+  #
+  # It runs for a developer who WORKS ON the backend lane: the container is that lane's,
+  # and its fix writes there.
   - id: lane_resolve
     action: execute_script
     on_error: continue
@@ -537,12 +568,12 @@ workflow:
       - { name: be_lane_id,     from: "$.backend_lane_id" }
       - { name: be_source_path, from: "$.backend_source_path" }
   - id: wiring_arm
-    condition: "{{be_declared}} == true"
+    condition: "{{be_working}} == true"
     action: set
     vars: { wiring_ok: "false" }
 
   - id: wiring_loop
-    condition: "{{be_declared}} == true"
+    condition: "{{be_working}} == true"
     action: loop
     while: "{{wiring_ok}} != true"
     max_iterations: 2
@@ -648,7 +679,7 @@ workflow:
     on_error: continue
     script: { ref: actions }
     subcommand: test-run
-    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--also", "{{referrer_csv}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--also", "{{referrer_csv}}", "--kind", "{{working_kind}}"]
     outputs:
       - { name: integrity_ok,  from: "$.fence_green" }
       - { name: integrity_log, from: "$.log_tail" }
@@ -809,6 +840,7 @@ workflow:
 outputs:
   feature_dir: "{{feature_dir}}"
   bounded_context: "{{context}}"
+  working_lane: "{{working_lane}}"   # the lane(s) tested, fixed and scored — .appweaver/lane.json
   # The second master this gate scored against — the RESOLVED path, which context-paths
   # reports whether or not the file is there. `model_scored` is the one that says whether
   # it actually reached the passes: false means the conformance pass checked the gate

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

@@ -29,12 +29,25 @@
 # lane declared, a lane with no lane root folder, a lane root folder that is not on disk, and two
 # lanes claiming overlapping subtrees all still stop the run.
 #
+# 1.4.0 — THE WORKING LANE. Only the lanes the developer on this machine works on
+# (.appweaver/lane.json — select-stack writes the default, select-lane narrows it) are
+# compiled, checked on disk and handed to the fix loop. A backend developer's build is not
+# stopped by a frontend lane that is not scaffolded yet, nor failed by its compile errors,
+# and its fix loop is never handed the frontend's files. With the default (every declared
+# lane) every lane is compiled, as before.
+#
+# 1.5.0 — THE BACKEND PUBLISHES ITS API DOCUMENT. After a green compile, a developer who
+# works on the service lane exports its API document again (contract-export: start the
+# service, save what it serves under contracts/ in its lane root folder, stop it), so the
+# committed document follows the fixes this loop made. The frontend lane reads that
+# document and never starts the service. A failed export warns and the build stays green.
+#
 # Launch:  /appweaver build [strategy]
 # =============================================================================
 
 name: aw-spec-build
-description: Compile the feature by running EVERY declared lane's own build command, fix compile errors against the design intent, then record the touched files in the slice's knowledge concept. Backend-only, frontend-only and full-stack projects all compile here — the gate requires a lane declaration, not a lane of a particular kind. Loads TECHNICAL rules only (tech-rule-bindings) — no domain rules reach this stage.
-version: 1.3.0
+description: Compile the feature by running the build command of every lane the developer works on (.appweaver/lane.json — every declared lane by default), fix compile errors against the design intent, then record the touched files in the slice's knowledge concept; a developer who works on the service lane then re-exports its API document (contracts/openapi.json), which the frontend lane reads from the commit. Backend-only, frontend-only and full-stack projects all compile here — the gate requires a lane declaration, not a lane of a particular kind. Loads TECHNICAL rules only (tech-rule-bindings) — no domain rules reach this stage.
+version: 1.5.0
 agent_agnostic: true
 dialect: aw-spec.orchestrator/v1
 
@@ -57,6 +70,16 @@ standards:
 
 vars:
   build_ok: "false"
+  working_kind: ""        # one kind when the developer works on one lane of two, else empty — every declared lane
+  working_root: ""
+  working_test_path: ""
+  be_working: "false"     # the service lane is declared and this developer works on it — it publishes the API document
+  contract_ok: ""
+  export_doc: ""
+  contract_reason: ""
+  contract_log: ""
+  contract_already: "false"
+  contract_fresh: "true"
 
 workflow:
 
@@ -98,6 +121,8 @@ workflow:
     with: { require: "", command: "/appweaver build" }
 
   # The slice's source files, from its OKF concept — what the fix loop below is handed.
+  # `--under` keeps the working lane's own two subtrees when the developer works on one
+  # lane of two; both are empty otherwise, and the slice's whole file list is kept.
   # This replaces the retired `design-paths` fence scan: the tech-agnostic backend-plan.md
   # carries no ```lang path=… code blocks, so that scan returned nothing and the fixer
   # was told to "fix the source files in context" with an EMPTY context. `source_files`
@@ -109,7 +134,7 @@ workflow:
     on_error: continue
     script: { ref: xref }
     subcommand: concept-paths
-    args: ["--feature-dir", "{{feature_dir}}"]
+    args: ["--feature-dir", "{{feature_dir}}", "--under", "{{working_root}}", "--under", "{{working_test_path}}"]
     outputs:
       - { name: all_paths,     from: "$.paths" }
       - { name: paths_missing, from: "$.missing" }
@@ -136,7 +161,7 @@ workflow:
         on_error: continue
         script: { ref: actions }
         subcommand: build-compile
-        args: ["--feature-dir", "{{feature_dir}}"]
+        args: ["--feature-dir", "{{feature_dir}}", "--kind", "{{working_kind}}"]
         outputs:
           - { name: build_ok,   from: "$.ok" }
           - { name: build_tool, from: "$.tool" }
@@ -167,6 +192,38 @@ workflow:
     on_false: stop
     on_false_message: "Build still failing after 3 fix attempts. Last log: {{build_log}}"
 
+  # THE API DOCUMENT, published from the code that just compiled — by the developer who
+  # works on the service lane, so the frontend developer reads it from the commit instead of
+  # starting the service. Advisory: a failed export warns and the build stays green.
+  - id: contract_export
+    condition: "{{be_working}} == true"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: contract-export
+    outputs:
+      - { name: contract_ok,      from: "$.ok" }
+      - { name: export_doc,       from: "$.doc" }
+      - { name: contract_reason,  from: "$.reason" }
+      - { name: contract_already, from: "$.already_running" }
+      - { name: contract_log,     from: "$.log_tail" }
+  - id: warn_contract_export
+    condition: "{{be_working}} == true"
+    action: verify_context
+    require_true: contract_ok
+    on_false: continue
+    on_false_message: "API DOCUMENT NOT EXPORTED — {{contract_reason}}. The build is green; only the published document is out of date. The service lane is started with its `contract_run` command and its document fetched from its `contract` URL, both read from .appweaver/stacks.json or else its stack profile — correct them there, start anything the service needs, and re-run build. Service output: {{contract_log}}"
+  - id: contract_stale_flag
+    condition: "{{contract_already}} == true"
+    action: set
+    vars: { contract_fresh: "false" }
+  - id: warn_contract_stale
+    condition: "{{be_working}} == true"
+    action: verify_context
+    require_true: contract_fresh
+    on_false: continue
+    on_false_message: "WARNING — the API document was {{contract_reason}}. Stop that service and re-run build to export the code as it is now."
+
   # Record what the fix loop touched in the slice's OKF concept. This replaces the retired
   # `design-reconcile` step, which copied on-disk file bodies back into the design doc's
   # path-tagged fences — meaningless now that backend-plan.md describes contracts, not code (and
@@ -205,4 +262,6 @@ outputs:
   # Declared in the concept but absent on disk — index drift worth an operator's eye
   # (a file moved or deleted without re-running the owning slice). Advisory, never gated.
   stale_source_files: "{{paths_missing}}"
+  working_lane: "{{working_lane}}"   # the lane(s) compiled — .appweaver/lane.json
+  api_document: "{{export_doc}}"     # the service's API document, exported after the green compile — commit it for the frontend lane
   next: "/appweaver analyze-slice"

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

@@ -40,10 +40,11 @@
 # drift. What this stage must NOT do is hide that by merging a delta plan: the plan would
 # then agree with the spec without any run of `plan` ever having derived it.
 #
-# ✅ THE DETECTION IS BUILT (2026-09-14). Every master-mode analyze-plan run leaves
-# `.aw-plan-gate.json` — the sha256 of spec.md, the context's domain-model.md and each lane
-# plan it read, and its verdict — and `implement` reads it through plan-gate-check before any
-# lane generates, refusing a master run whose plans are no longer the ones the gate checked. So after this merge the
+# ✅ THE DETECTION IS BUILT (2026-09-14). Every master-mode analyze-plan run leaves a receipt
+# per gated lane, `.aw-plan-gate.<lane>.json` — the sha256 of spec.md, the context's
+# domain-model.md and that lane's plan, and that lane's verdict — and `implement` reads it
+# through plan-gate-check before the lane generates, refusing a lane whose plan is no longer
+# the one the gate checked. So after this merge the
 # plans are not merely "visibly behind": the next `implement` on the master path says so and
 # stops, naming `plan main`. A feature with no receipt has never been gated since the receipt
 # existed and is reported, never refused.