aw-spec-cli 0.1.8 → 0.1.9

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

@@ -0,0 +1,265 @@
+# =============================================================================
+# aw-spec-foundation (orchestrator) — scaffold a project from a foundation bundle
+#
+# 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.
+#
+# Interactive confirmations (proceed / overwrite / reference sample) ride the
+# checkpoint channel under EVERY strategy.
+#
+# Launch via the parametric skill:  /appweaver foundation [strategy]
+#   Interactive (no args): LISTS the available foundations to pick from, then ASKS
+#   for the app (project) name — both deterministic, no LLM. Fast path still works:
+#     /appweaver foundation agent VerticalSlice AppWeaver.Health
+#
+# Headless:
+#   python3 .appweaver/orchestrator/orchestrator.py \
+#     .appweaver/orchestrator/workflows/aw-spec-foundation.orch.yaml \
+#     --checkpoint .appweaver/orchestrator/.state/foundation.state.json \
+#     --input "VerticalSlice AppWeaver.Health" --json
+# =============================================================================
+
+name: aw-spec-foundation
+description: Scaffold a complete, compiling project — pick from the available foundation bundles and enter the app name, then unpack the verified bundle and rename its sentinel to your app name. Selection is zero-LLM (list + pick + ask).
+version: 1.1.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: "Optional fast path: FoundationName [AppName] [OutputDirectory]. Omit to pick a foundation from the list and be asked for the app name."
+    required: false
+    bind: USER_INPUT
+
+scripts:
+  actions:
+    sh:  .appweaver/scripts/bash/aw-spec-actions.sh
+    ps1: .appweaver/scripts/powershell/aw-spec-actions.ps1
+
+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)
+
+workflow:
+
+  # 1a. LIST the available foundations (deterministic foundations/<ecosystem>/<Name>/<Name>.pack.txt
+  #     scan — no LLM), narrowed to the ecosystems the declared lanes belong to. A
+  #     bundle is a whole compiling project in one ecosystem's build system, so the
+  #     list a Spring repo is shown and the list a .NET repo is shown are different
+  #     lists; `all_foundations` keeps the unfiltered set for the gate message below.
+  #     A direct "Foundation App [out]" argument is parsed here too as an optional
+  #     fast path (preselect_name / preselect_app / out_dir).
+  - id: list_foundations
+    action: execute_script
+    script: { ref: actions }
+    subcommand: foundation-list
+    args: ["--args", "{{USER_INPUT}}"]
+    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: out_dir,          from: "$.out_dir" }
+
+  - id: have_foundations
+    action: verify_context
+    require_non_empty: foundations
+    on_empty: stop
+    on_empty_message: >
+      No foundation bundle is available for this repository. Bundles present:
+      {{all_foundations}}; the ecosystem(s) this repository declares in
+      .appweaver/stacks.json: {{lane_ecosystems}}. 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 repo — it is a second, foreign project beside it. Either add a
+      bundle under foundations/<ecosystem>/<Name>/<Name>.pack.txt for your stack (see the
+      pack scripts in that directory), or scaffold with the stack's own tooling (Spring
+      Initializr, `npm create`, `cargo new`, …) and declare the result with
+      /appweaver select-stack — 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", "{{out_dir}}"]
+    outputs:
+      - { name: locate_ok,  from: "$.ok" }
+      - { name: locate_msg, from: "$.reason" }
+      - { name: available,  from: "$.available" }
+      - { name: fname,      from: "$.name" }
+      - { name: app,        from: "$.app" }
+      - { name: out_dir,    from: "$.out_dir" }
+      - { 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}}
+      Output:     {{out_dir}}
+      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", "{{out_dir}}", "--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", "{{out_dir}}", "--force", "{{overwrite}}"]
+    outputs:
+      - { name: written, from: "$.written" }
+
+  # 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", "{{out_dir}}"]
+    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", "{{out_dir}}", "--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", "{{out_dir}}", "--sentinel", "{{sentinel}}"]
+    outputs:
+      - { name: clean,   from: "$.clean" }
+      - { name: residue, from: "$.residue" }
+
+outputs:
+  foundation: "{{fname}}"
+  app: "{{app}}"
+  output_dir: "{{out_dir}}"
+  files_written: "{{written}}"
+  reference_files: "{{ref_written}}"
+  sentinel_clean: "{{clean}}"
+  sentinel_residue: "{{residue}}"
+  note: "Foundation scaffolded into {{out_dir}} ({{written}} file(s), sentinel renamed to {{app}}). Configure your AppWeaver.* NuGet feed and run the AppHost to confirm the scaffold starts before building on it."
+  next: "/appweaver select-feature   (pick the feature to build; every stage from specify onward reads that active feature and stops without it. If this workspace has governed projects under guardrails/projects/, run /appweaver select-domain first — it is one-time and optional.)"

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

@@ -0,0 +1,253 @@
+# =============================================================================
+# aw-spec-implement-delta (orchestrator) — generate the DELTA's code from the design
+#
+# The CR analog of implement, SCOPED to the open change. GENERATE / edit exactly the
+# source files + paired tests that delta-design.md marks ADDED or MODIFIED, into the
+# existing project tree, using the master design.md as the base context. The delta
+# design is the authoritative source for WHAT the change is — analyze-delta-design already
+# conformed it to the delta spec. The target STACK is bound from the constitution.
+# implement-delta does NOT touch spec.md / design.md and does NOT close the change —
+# finalize-delta merges the delta into the master docs afterward, and close-delta bumps
+# the version at the very end.
+#
+#   specify → design → ⟨review⟩ → analyze-delta-design → implement-delta   ← you are here
+#       → build → finalize-delta → analyze-slice → close-delta
+#
+# Prereqs: run /appweaver analyze-delta-design first (the delta design is conformed),
+# and the project must already be scaffolded (/appweaver foundation) — implement-delta
+# GENERATES into that tree.
+#
+# Launch:  /appweaver implement-delta [strategy] [guidance]
+# =============================================================================
+
+name: aw-spec-implement-delta
+description: Generate only the source files + paired tests the open change's delta-design.md marks ADDED/MODIFIED, into the existing project tree, bound to the project's stack. Model-driven, delta-design-scoped; does not touch the master docs or close the change.
+version: 1.0.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: Optional implementation guidance (stack hints, focus area).
+    required: false
+    bind: USER_INPUT
+
+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
+
+# Sticky standards seed = the UNIVERSAL always-on rule only (ai-rules). Same FRAMEWORK /
+# code-generation set as the forward implement — HOW to build — but no longer hardcoded:
+# it is CONFIGURATION, loaded per-command from guardrails/projects/<project>/tech-rule-bindings.md
+# by the tech-select module (see the tech_select step below). No domain rule files:
+# everything domain reached the delta via delta-spec → delta-design; the tech map lists
+# only technical files. The architecture principles come via constitution.technical.md
+# (referred to directly, as-is — NOT mapped); the structure via design.md. (missing skipped)
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+workflow:
+
+  # 0. TECHNICAL rule files → sticky standards (configuration, not hardcoded).
+  #    tech-select reads guardrails/projects/<project>/tech-rule-bindings.md under
+  #    "## /aw-spec-implement-delta" and loads that set into the sticky standards the
+  #    agent_generate step ALWAYS prepends. No domain rule file is loaded here — the tech
+  #    map lists only technical files (rule-partition intact). No blocking gate: an
+  #    unconfigured project soft-continues (constitution.technical.md still carries the
+  #    tech base, referred to directly below).
+  - id: tech_select
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-implement-delta }
+
+  # 1. Resolve the current feature + its master design (the base context).
+  - 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: design_doc,    from: "$.design_file" }
+      - { 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 implement-delta."
+
+  - 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 design (and, for a change, /appweaver specify + design + analyze-delta-design) first."
+
+  # 1b. Read the OPEN change (opened by cr). implement-delta needs a change to implement.
+  # Require the SERVICE LANE and its source path — implement-delta writes into the
+  # subtree the lane owns, exactly as implement does.
+  - id: lane_gate
+    action: include
+    module: .appweaver/orchestrator/modules/lane-gate.orch.yaml
+    with: { require: backend, command: "/appweaver implement-delta" }
+
+  - id: read_change
+    action: execute_script
+    script: { ref: actions }
+    subcommand: version-read
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: active_change, from: "$.active_change" }
+      - { name: has_change,    from: "$.has_change" }
+
+  - id: require_change
+    action: verify_context
+    require_true: has_change
+    on_false: stop
+    on_false_message: "No open change on this feature. Run /appweaver specify <change> then /appweaver design, review the delta docs, and /appweaver analyze-delta-design before implement-delta."
+
+  # 1c. Require the PROJECT — a scaffolded, compiling tree — to be present. implement-delta
+  #     GENERATES the delta's code INTO it; with no project there is nowhere to place the
+  #     files. Searches the LANE'S OWN subtree for any ecosystem manifest before falling
+  #     back to the whole repo, so a stack that ships no foundation bundle passes on the
+  #     project its team scaffolded.
+  - id: detect_foundation
+    action: execute_script
+    script: { ref: actions }
+    subcommand: detect-project
+    args: ["--root", "{{lane_source_path}}"]
+    outputs:
+      - { name: foundation_present, from: "$.scaffolded" }
+      - { name: project_markers,    from: "$.markers" }
+      - { name: project_scope,      from: "$.scope" }
+
+  - id: foundation_gate
+    action: verify_context
+    require_true: foundation_present
+    on_false: stop
+    on_false_message: "No project found under the {{lane_id}} lane's source path `{{lane_source_path}}`, nor anywhere else in this repository. implement-delta GENERATES the delta's code into an existing project tree, so one has to be scaffolded first: run /appweaver foundation <FoundationName> <AppName> where a foundation bundle ships for this stack, or create the project with the stack's own tooling under that path. Any ecosystem manifest marks it — .sln/.csproj, pom.xml, build.gradle(.kts), package.json, go.mod, Cargo.toml or pyproject.toml."
+
+  # 2. Pre-execution hooks.
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_implement_cr"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # 3. Model-driven generation SCOPED to the delta: delta-design.md → the ADDED/MODIFIED
+  #    source files + paired tests. The master design.md is the base (unchanged elements
+  #    the delta depends on); the constitution/stack profile fixes HOW. The delta spec is
+  #    in context ONLY to cite traceability ids on the paired tests.
+  # Context is fed via build_context — agent_generate reads the ENVELOPE, not a
+  # step-level context: key (unlike agent_author/agent_query which read both).
+  - id: ctx_generate
+    action: build_context
+    context:
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-design.md" }
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-spec.md" }
+      - { path: "{{design_doc}}" }
+      - { path: .appweaver/memory/constitution.technical.md, optional: true } # technology base ONLY — no domain
+  - id: generate
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      Implement ONLY this change into the existing project tree, STRICTLY from its
+      delta-design.md (in context). The delta design is the authoritative source of
+      WHAT changed — analyze-delta-design already conformed it to the delta spec. The
+      master design.md (in context) is the BASE: the unchanged elements the delta
+      depends on; do NOT regenerate them. Guidance: {{USER_INPUT}}
+      Rules:
+      - SCOPE = THE DELTA ONLY. Realise exactly the elements delta-design.md marks
+        ADDED (create the new file) or MODIFIED (edit the existing file in place).
+        Touch NOTHING the delta does not list, except the regression re-tests below.
+      - THE DELTA DESIGN IS THE ONLY DOMAIN INPUT. You have the delta design + master
+        design.md + framework/code standards, and NO domain rule files. Introduce NO
+        domain rule, identifier, terminology, or behaviour the delta design does not
+        state. If something domain seems missing, STOP and surface it (fix it in cr /
+        analyze-delta-design); never invent it from memory.
+      - BIND THE STACK: this lane is `{{lane_id}}` — {{lane_title}}, language
+        {{lane_language}} ({{lane_ecosystem}}), declared in .appweaver/stacks.json and
+        compiled with `{{lane_build}}`, tested with `{{lane_test}}`. Generate in THAT
+        language and framework and no other, using its idioms, its project layout and
+        its test framework. Take persistence, messaging and the remaining technology
+        choices from the constitution's technology base + the loaded standards; the
+        design is technology-agnostic, so do not re-decide anything already fixed there.
+        If the 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 `{{lane_source_path}}` — the source path the `{{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.
+      - 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
+        in the tree.
+      - 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 invariant, handler orchestration, API error contract, the Cross-Cutting
+        Concerns realisations (audit / retention / data-exposure — CN-/DC-) and the
+        External Integrations table's contracts (IC-) exactly as the delta design states.
+      - COMPONENTS: if a delta element depends on a framework component, code against
+        its ABSTRACTION / port as the delta design declares — do NOT hand-roll it.
+        Installing the component (packages, wiring, config) is /appweaver
+        add-component <Component>; if the port isn't present, code to it and note that
+        as the prerequisite.
+      - Author a paired test for every ADDED/MODIFIED behaviour / use-case / endpoint;
+        derive the cases from the delta design's pre/post/invariant contracts and cite
+        the delta-spec id (FR / BR / CN / DC / IC / US).
+      - REGRESSION: for each element in the delta design's "Regression targets", verify
+        (add/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) / Workaround (WA-n),
+        mark it with a comment citing that id.
+    outputs:
+      - { name: files, from: "$.files" }
+
+  - id: verify_generated
+    action: verify_context
+    require_non_empty: files
+    on_empty: stop
+    on_empty_message: "No files generated. Ensure /appweaver design produced a filled delta-design.md (not the empty template) and it passed /appweaver analyze-delta-design, then re-run."
+
+  # 3b. Refresh THIS slice's OKF concept source_files with the delta's changed files —
+  #     UNION, never replace (the delta is scoped; {{files}} is only the ADDED/MODIFIED
+  #     files). The cross-slice EDGES are refreshed later in finalize-delta, AFTER the delta
+  #     merges into the master design.md (here the master still holds the pre-change deps,
+  #     so recording edges now would read stale references). Best-effort enrichment.
+  - id: xref_concept_merge
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-upsert
+    args: ["--feature-dir", "{{feature_dir}}", "--source-files", "{{files}}", "--merge"]
+    outputs:
+      - { name: okf_concept, from: "$.concept" }
+
+  # 4. Post-execution hooks.
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_implement_cr"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  feature_dir: "{{feature_dir}}"
+  cr_id: "{{active_change}}"
+  files: "{{files}}"
+  next: "/appweaver build → finalize-delta → analyze-slice → close-delta. COMPILE FIRST (build), then finalize-delta runs the downstream fence and merges the delta into spec.md + design.md — but leaves the change OPEN. analyze-slice then verifies the slice against that now-merged master (tests, domain conformance, referrer blast radius) while a red result is still recoverable. close-delta LAST archives the change and bumps the version."