aw-spec-cli 0.1.8 → 0.1.9

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

@@ -0,0 +1,462 @@
+# =============================================================================
+# aw-spec-finalize-delta (orchestrator) — MERGE the delta into the master docs
+#
+# The fourth of the five CR stages. Fold the open change's delta docs into the feature's
+# masters (doc-first merge) and refresh the cross-slice edges from the now-merged design.
+# After this the master docs describe the shipped-plus-change state — but THE CHANGE
+# REMAINS OPEN.
+#
+# HOW MANY MASTERS. Two always — spec.md + design.md. THREE where the feature holds a UI
+# half (design.ui.md). This stage is the ONLY writer of the masters, so every document the
+# change can move has to move here: a UI delta left in the change dir is lost the moment
+# close-delta archives it, and a UX- merged into the spec that reaches no design is a
+# standard nothing implements.
+#
+# THE UI LANE HAS ITS OWN COMMANDS — ⌛ design-ui / delta-design-ui author design.ui.md and
+# delta-design.ui.md, exactly as design / delta-design author the service pair. This stage
+# does not author either one; it MERGES whichever of them the feature has. The two UI paths
+# it must handle are therefore different, and both are normal:
+#   • MASTER + DELTA — the change has an experience half. Merge it, then append the row.
+#   • MASTER, NO DELTA — the change never reached the UI, or ⌛ delta-design-ui has not run.
+#     Append the Change History row and touch nothing else. The row is not bookkeeping
+#     for its own sake: close-delta stamps design.ui.md to the new version alongside its
+#     siblings (version-stamp covers all three), so a header carrying a version that no
+#     row explains is indistinguishable from a merge that silently dropped one.
+# A feature with no design.ui.md at all has no UI half and merges two documents, unchanged.
+#
+#   specify → design → analyze-delta-design → implement-delta → build
+#       → finalize-delta   ← you are here
+#       → analyze-slice → close-delta
+#
+# MERGE HERE, CLOSE LATER. Archiving the change + bumping the version used to happen in
+# this stage; both moved to close-delta, which runs AFTER analyze-slice. The split buys
+# two things:
+#   1. analyze-slice reads a master spec.md that ALREADY carries the change, so its fix
+#      loops repair code against the true current requirements — no delta-awareness, no
+#      risk of "fixing" the change's new tests back toward pre-change behaviour.
+#   2. A red analyze-slice still lands on an OPEN change, so the remedy is "fix and
+#      re-run" rather than a NEW change to repair the one already shipped.
+# The downstream fence below still guards the MERGE (a change that breaks a dependent
+# must not reach the master docs); close-delta guards nothing — it is the bookkeeping.
+#
+# Prereqs: run /appweaver implement-delta then build first (the delta's code is
+# generated and compiles), so after the merge the master docs and the code agree.
+# finalize-delta edits ONLY the master docs; it does not generate code.
+#
+# Launch:  /appweaver finalize-delta [strategy]
+# Prereq:  an OPEN change whose delta was implemented.
+# =============================================================================
+
+name: aw-spec-finalize-delta
+description: Merge the open change's delta-spec into spec.md, delta-design into design.md and — where the feature has a UI half — delta-design.ui.md into design.ui.md (doc-first), append the Change History to each in lockstep, and refresh the cross-slice edges from the merged design. Gated first by a SCOPED downstream fence over the transitive blast radius (fence_green), which writes a triage report and asks Abort/Override on red. Leaves the change OPEN — analyze-slice runs next against the merged master, and close-delta archives the change and bumps the version.
+version: 1.3.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
+
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+vars:
+  active_change: ""
+  has_change: "false"
+  version: ""           # the CURRENT version — unchanged by this stage
+  next_version: ""      # what close-delta will bump to; the number the Change History rows carry
+  downstream_count: "0"    # transitive + placeholder-filtered dependents (blast radius); drives the gate
+  downstream_csv: ""       # the blast-radius names, fed to the scoped fence's --also and shown to the human
+  fence_ok: "true"         # default green so the gate is a no-op when nothing downstream
+  gate_decision: "clean"   # audit: 'clean' unless a RED fence was deliberately overridden
+  ui_design_exists: "false"  # the feature holds a design.ui.md master ⇒ this merge has a THIRD target.
+                             # feature_paths runs on_error:continue, so this default is what a failed
+                             # readback falls back to: the two-master merge, unchanged.
+  ui_design_doc: ""          # specs/<Feature>/design.ui.md — the UI merge target
+
+workflow:
+
+  # 1. Resolve the current feature + its spec; require the spec (a merge target).
+  - 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: spec_exists, from: "$.spec_exists" }
+      - { name: ui_design_exists, from: "$.ui_design_exists" }   # ⇒ a third master to merge into
+      - { name: ui_design_doc,    from: "$.ui_design_file" }
+
+  - 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 finalize-delta."
+
+  - id: verify_spec
+    action: verify_context
+    require_true: spec_exists
+    on_false: stop
+    on_false_message: "No spec.md for the current feature. Run /appweaver specify + design first."
+
+  # 1b. Read the OPEN change (opened by cr). finalize-delta needs a change to close.
+  - 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" }
+      - { name: version,       from: "$.version" }
+      - { name: next_version,  from: "$.next_version" }
+
+  - id: require_change
+    action: verify_context
+    require_true: has_change
+    on_false: stop
+    on_false_message: "No open change on this feature — nothing to finalize. Run /appweaver specify → design → analyze-delta-design → implement-delta first."
+
+  # 1c. DOWNSTREAM GATE (hard, with a REVIEWED override). Who depends on this aggregate —
+  #     its OKF Cross-References, TRANSITIVELY (C→B→A all count) and placeholder-filtered
+  #     (the "_(none observed)_" row is NOT a dependent) = the real blast radius. If any
+  #     slice does, this change could ripple into it, so run a SCOPED regression fence over
+  #     this feature + its downstream closure (--scope slice --also <closure>) BEFORE the
+  #     doc merge, so a block leaves the repo untouched. The fence binds fence_GREEN (ran
+  #     AND matched >=1), not raw ok, so an empty / zero-match run is RED, never a vacuous
+  #     pass. If RED we do NOT hard-stop blindly: we WRITE a triage report, then surface the
+  #     failing log + dependent slices and ASK the developer — Abort (a real downstream
+  #     break: fix it first) or, having reviewed the log (pre-existing / flaky / unrelated),
+  #     deliberately Override and close anyway. Non-interactive / CI runs take the FIRST
+  #     option (Abort), so automation never silently overrides. Skipped when nothing depends
+  #     on this slice (count 0) or the fence is green.
+  - id: xref_impact
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: list
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: downstream_count, from: "$.referrer_closure_count" }   # transitive + placeholder-filtered
+      - { name: downstream_csv,   from: "$.referrer_closure_csv" }     # blast-radius names → --also + display
+
+  - id: run_downstream_fence
+    condition: "{{downstream_count}} != 0"
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: test-run
+    args: ["--feature-dir", "{{feature_dir}}", "--scope", "slice", "--also", "{{downstream_csv}}"]
+    outputs:
+      - { name: fence_ok,   from: "$.fence_green" }
+      - { name: fence_tool, from: "$.tool" }
+      - { name: fence_log,  from: "$.log_tail" }
+
+  # Whenever the fence RAN (there are dependents), write a durable report BEFORE asking /
+  # stopping — written green OR red, mirroring characterize's drifted-tests.md, so a later green
+  # close never archives a STALE red report. On red it is the triage a developer reads while
+  # deciding Abort vs Override and, if Overridden, is ARCHIVED with the change as the "closed over
+  # red" record; on green it is a short all-clear that overwrites any prior red report. Skipped
+  # only when nothing depends on this slice (no fence ran, nothing to report).
+  - id: ctx_broken_downstream
+    action: build_context
+    condition: "{{downstream_count}} != 0"
+    vars:
+      active_change: "{{active_change}}"
+      downstream_count: "{{downstream_count}}"
+      downstream_csv: "{{downstream_csv}}"
+      fence_ok: "{{fence_ok}}"
+      fence_log: "{{fence_log}}"
+    context:
+      - { path: "{{spec_file}}" }
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-design.md" }
+  - id: write_broken_downstream
+    action: agent_author
+    condition: "{{downstream_count}} != 0"
+    include_standards: false                       # a triage report, not generated code
+    output_target: { type: file, path: "{{feature_dir}}/changes/{{active_change}}/broken-downstream.md" }
+    task: |
+      Author the DOWNSTREAM report for change {{active_change}}: the result of re-running this
+      change against the aggregates that DEPEND ON this feature. finalize-delta does NOT fix a
+      downstream slice (that is the downstream slice's own job). Downstream blast radius
+      ({{downstream_count}}): {{downstream_csv}}. The fence result was fence_green={{fence_ok}}
+      (true = every downstream test passed; false = at least one failed). Test log:
+      {{fence_log}}
+      Always write the file (it is regenerated on every finalize-delta run so a green close never
+      leaves a stale red report standing). Stamp when it was generated in both cases.
+
+      IF fence_green is TRUE (all passed): write a SHORT all-clear — the heading
+      `# Broken Downstream — change {{active_change}}`, then a few lines stating that the
+      {{downstream_count}} slice(s) that use this feature ({{downstream_csv}}) were re-run against
+      this change and all passed, so nothing downstream broke. No per-slice sections; invent nothing.
+
+      IF fence_green is FALSE (something failed): write the triage record —
+      - `# Broken Downstream — change {{active_change}}` and a one-line statement: aggregates that
+        USE this feature and whose tests went red when this change was run against them, found by
+        finalize-delta's downstream gate. Note it is the record a human reads while deciding Abort vs
+        Override, and if the change is Overridden it is archived with the change as the record of
+        what was knowingly closed over.
+      - A SUMMARY line: total downstream slices in the blast radius, and how many have a failing test.
+      - One `##` section per DOWNSTREAM slice that has a failing test — attribute a failure to a
+        slice by matching the failing test names in the log to the slice's name. Under it, on their
+        own labelled lines: the downstream aggregate, the failing test(s) named in the log, what
+        broke (as far as the log shows), and a RESOLUTION line — either this change broke the
+        downstream slice's expected contract (fix it in the downstream slice's OWN CR, or re-baseline
+        its golden-master) or the failure is pre-existing / flaky / unrelated (a candidate for a
+        reviewed Override). Recommend one; do not claim certainty the log does not support.
+      - A closing `## How to use this file`: if you Abort, resolve each finding in the downstream
+        slice (or re-baseline its golden-master via a CR) then re-run /appweaver finalize-delta; if
+        you Override, this is the archived record of what was knowingly closed over. Do not edit in place.
+      Attribute only what the log supports; invent no failures. Do NOT propose an edit to THIS
+      feature's code or docs to silence a downstream failure — that would hide a real contract break.
+    outputs:
+      - { name: broken_downstream_file, from: "$.files" }
+
+  # Fires ONLY when the fence is RED — a failed test-run binds fence_ok=false, which renders
+  # as the string 'false' (json.dumps), so this condition is exactly "the fence is red".
+  # A green fence or no downstream users leaves fence_ok truthy and skips both this and the
+  # gate. The FIRST option is the safe default (non-interactive / CI → Abort). The chosen
+  # label is bound to gate_decision and later written into the OKF log for an audit trail.
+  - id: ask_override
+    condition: "{{fence_ok}} == false"
+    action: ask
+    prompt: |
+      DOWNSTREAM REGRESSION FENCE RED after change {{active_change}}.
+      {{downstream_count}} slice(s) depend on this aggregate: {{downstream_csv}}
+      Triage report: {{feature_dir}}/changes/{{active_change}}/broken-downstream.md
+      -- last test log ------------------------------------------------------------
+      {{fence_log}}
+      -----------------------------------------------------------------------------
+      Review the failing test(s) and the triage report. Is this break caused by THIS
+      change, or is it unrelated (a pre-existing / flaky / different-slice failure)?
+        - Abort    = a real downstream break: stop, fix the downstream slice (or open
+                     a CR on it to re-baseline its golden-master), then re-run finalize-delta.
+        - Override = you have reviewed the log and are DELIBERATELY closing X anyway.
+    options:
+      - "Abort (fix downstream first)"
+      - "Override (reviewed; close X anyway)"
+    answer_var: gate_decision
+
+  - id: downstream_gate
+    condition: "{{fence_ok}} == false"
+    action: verify_context
+    require_value: gate_decision
+    equals: "Override (reviewed; close X anyway)"
+    on_mismatch: stop
+    on_mismatch_message: "finalize-delta ABORTED — downstream fence RED after change {{active_change}} and the override was declined. {{downstream_count}} slice(s) depend on this aggregate ({{downstream_csv}}): the change would break a slice that USES this one. Triage: {{feature_dir}}/changes/{{active_change}}/broken-downstream.md. Fix the downstream break; or, if the behaviour change is intended, open a CR on the affected slice to re-baseline its golden-master. Then re-run /appweaver finalize-delta. Last log: {{fence_log}}"
+
+  # 2. Ensure the master design.md exists (idempotent) — the second merge target.
+  - id: design_scaffold
+    action: execute_script
+    script: { ref: actions }
+    subcommand: design-scaffold
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: design_doc, from: "$.design_doc" }
+
+  # 3. Pre-execution hooks.
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_finalize_cr"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # 4. DOC-FIRST merge: fold the two delta docs into the two master docs in place.
+  # 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_merge
+    action: build_context
+    context:
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-spec.md" }
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-design.md" }
+      - { path: "{{spec_file}}" }
+      - { path: "{{design_doc}}" }
+      # THE UI LANE's pair, INDEPENDENTLY optional — the merge task reads which of them
+      # arrived as its instruction. Neither: a backend-only feature, and a two-master
+      # merge is the complete outcome. Master only: the change did not reach the UI, or
+      # ⌛ delta-design-ui has not run — Change History row only. Both: a full third merge.
+      # Optional rather than gated because a missing UI document is an ordinary state
+      # here, not a misconfiguration worth stopping the merge over.
+      - { path: "{{ui_design_doc}}", optional: true }
+      - { path: "{{feature_dir}}/changes/{{active_change}}/delta-design.ui.md", optional: true }
+  - id: merge_delta
+    action: agent_generate
+    tools: "Read,Write,Edit"
+    permission_mode: acceptEdits
+    task: |
+      Merge the open change {{active_change}} into this feature's MASTER docs (all in
+      context), DOC-FIRST. The delta docs (in context) are the source of the change;
+      apply them and change nothing else.
+      HOW MANY MASTERS: spec.md and design.md always. design.ui.md — the FRONTEND lane's
+      master — only where it is in context (ui_design_exists={{ui_design_exists}}); its
+      delta, delta-design.ui.md, may or may not be there beside it. Absent both, the
+      feature has no UI half and merging two documents is the COMPLETE outcome, not a
+      step you skipped.
+      To spec.md:
+      - Add each ADDED user story as a US-n tagged `Added: {{active_change}}`, and fold
+        the ADDED / MODIFIED / REMOVED FR / BR / CN- / DC- / IC- / UX- items into their
+        sections using the master's vocabulary (EARS FR, BR invariants, etc.). Every class
+        the delta authored is merged, including UX- into Experience Standards: that section
+        is the UI lane's only carrier, so a UX- item left behind reaches no UI phase.
+      - Where a lift section (Constraints & NFRs, Data Classification, Integration
+        Contracts, Experience Standards) still reads "None", its first merged item REPLACES
+        that placeholder; a section the delta does not touch keeps its "None" verbatim.
+      - Apply every MODIFIED item as an in-place edit of the existing item; apply every
+        REMOVED item by removing it. Keep the rest of spec.md VERBATIM.
+      - Append a Change History row for {{active_change}} (date + one-line summary).
+        Its Version cell is {{next_version}} — the version this change ships as.
+      To design.md:
+      - ADD each new design element in its own structural section; apply each MODIFIED
+        element as an in-place edit of the existing element; remove each REMOVED element.
+      - Fold the delta's new DA-n / WA-n into the design's two deferral ledgers, and keep
+        the Traceability section in sync — every new FR / BR / CN- / DC- / IC- / US- / SC-
+        gets a design home. UX- is NOT among them: the service design realises no
+        experience standard, so a Traceability row for one is a fabrication. Keep the rest
+        of design.md VERBATIM.
+      - Append a Change History row for {{active_change}} (date + one-line summary),
+        Version cell {{next_version}}, in lockstep with the spec's row.
+      To design.ui.md — ONLY where it is in context. TWO CASES, decided by whether
+      delta-design.ui.md came with it:
+      - NO delta-design.ui.md in context (or one whose Change summary reads "No UI
+        consequence", its ADDED / MODIFIED / REMOVED sections all None): merge NOTHING
+        into the body. The change was server-side, or the UI lane's own delta command
+        has not run for it. Append ONLY a Change History row for {{active_change}} (date,
+        Version cell {{next_version}}, summary stating the change carried no UI content)
+        and change nothing else — close-delta stamps this document to {{next_version}} alongside
+        its siblings, so a header carrying a version that no row explains is
+        indistinguishable from a merge that dropped one. Do NOT invent UI content to
+        justify the row, and do NOT infer the experience change from the service delta:
+        design.md is not this document's source.
+      With delta-design.ui.md in context:
+      - ADD each new screen, component, state, interaction or contract binding into the
+        master's OWN section — the delta's "Section (§ in design.ui.md)" column names it.
+        Apply each MODIFIED element as an in-place edit of that element and remove each
+        REMOVED one. A shared component or shared state container is edited ONCE, where
+        the master defines it, never duplicated into a second place.
+      - Fold the delta's interaction states into the states the master already records
+        for those interactions, and its new DA-n / WA-n into the master's two ledgers.
+      - Keep the Traceability section — the lane's spine — in sync: every UX- the delta
+        realises and every new US- it serves gets a row naming its UI home. UX- BELONGS
+        HERE AND ONLY HERE: design.md must never carry a UX- row (the service design
+        realises no experience standard) and design.ui.md is the sole document that
+        does, so a UX- merged into the spec and into neither design has been dropped.
+      - Where a mandatory ledger still reads "None (as of vX.Y)", its first merged item
+        REPLACES that placeholder; a ledger the delta does not touch keeps it verbatim.
+      - Append a Change History row for {{active_change}} (date + one-line summary),
+        Version cell {{next_version}}, in lockstep with the other two.
+      Leave the `**Version**:` HEADER of EVERY document in context exactly as it is — it
+      still reads {{version}} and does not move here. close-delta stamps the headers to
+      {{next_version}} at the moment it bumps active_version.json, so every carrier of
+      the number changes in one step by one mechanism. Do not invent a version anywhere.
+      Preserve every unrelated section of EVERY doc byte-for-byte. Do NOT touch the
+      delta docs (close-delta archives them later) and do NOT touch any source code.
+      Report the files you changed.
+    outputs:
+      - { name: merged_docs, from: "$.files" }
+
+  - id: verify_merged
+    action: verify_context
+    require_non_empty: merged_docs
+    on_empty: stop
+    on_empty_message: "The merge produced no changes — expected edits to spec.md and design.md (and design.ui.md where the feature has a UI half). Ensure the delta docs are filled (not the empty template) and re-run."
+
+  # 4b. Refresh the cross-slice EDGES from the NOW-MERGED master design.md — the delta's
+  #     added / removed references have just landed, so this is the first point they are
+  #     authoritative. Reconcile-on-write: new deps appear in the used slices'
+  #     Cross-References, dropped deps are pruned. `--origin auto` keeps the slice's
+  #     provenance (greenfield vs reverse-engineered) from its design.md, so this works
+  #     identically for a greenfield CR and a brownfield CR. Best-effort (never blocks close).
+  - id: xref_record
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: record
+    args: ["--feature-dir", "{{feature_dir}}", "--design", "{{design_doc}}", "--origin", "auto"]
+    outputs:
+      - { name: xref_edge_count, from: "$.edge_count" }
+      - { name: xref_origin,     from: "$.origin" }
+
+  # 4b-ii. Re-author the concept's Overview from the NOW-MERGED master design.md — the
+  #     change may have moved the aggregate's boundary or invariants, and this is the
+  #     first point the master states them. Section-scoped splice (the Cross-References
+  #     rows other slices own are untouched). Best-effort; an empty answer is a no-op.
+  - id: okf_overview
+    action: agent_query
+    context: ["{{design_doc}}"]
+    include_standards: false
+    schema: { overview: "<2-4 sentences of prose>" }
+    mock: { overview: "" }
+    task: |
+      Write the OKF knowledge-concept Overview for the aggregate that the merged
+      design.md (in context) describes. 2-4 sentences of PROSE, distilled from §1
+      Domain Model: name the aggregate ROOT and what the aggregate IS; state the
+      INVARIANTS it guards; state its TRANSACTION BOUNDARY — what it OWNS inside the
+      boundary vs what it only REFERENCES by id. Plain prose only: no headings, no
+      bullets, no code fences, no file paths, and no restating of the dependency edges
+      (those live in the Depends-On / Cross-References tables). Describe only what the
+      design states — invent nothing.
+    outputs:
+      - { name: okf_overview, from: "$.overview" }
+
+  - id: okf_overview_write
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-overview
+    args: ["--feature-dir", "{{feature_dir}}", "--text", "{{okf_overview}}"]
+
+  # 4c. Anchor the OKF bundle's freshness journal to the current commit (log.md, OKF §7).
+  #     Best-effort + git-aware: a no-op when there is no bundle or no commit, so it never
+  #     writes a non-conformant block. Records that this CR refreshed the cross-references.
+  - id: xref_log
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: log
+    args: ["--note", "CR {{active_change}} merged (downstream gate: {{gate_decision}}) — OKF cross-references refreshed"]
+    outputs:
+      - { name: xref_log, from: "$.log" }
+
+  # 5. NO ARCHIVE, NO VERSION BUMP HERE. Both moved to close-delta, which runs after
+  #    analyze-slice — see the header. The change stays OPEN past this stage on purpose:
+  #    it is what keeps a red analyze-slice recoverable ("fix and re-run") instead of
+  #    landing on an already-shipped version. The delta docs therefore remain in
+  #    changes/{{active_change}}/ even though their content is now merged; close-delta
+  #    moves them to changes/archive/.
+
+  # 6. Post-execution hooks.
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_finalize_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}}"
+  merged_docs: "{{merged_docs}}"
+  version: "{{version}}"
+  downstream_count: "{{downstream_count}}"
+  gate_decision: "{{gate_decision}}"
+  xref_edge_count: "{{xref_edge_count}}"
+  ui_design_updated: "{{ui_design_exists}}"   # true ⇒ design.ui.md was a target of this stage. It reports
+                                              # the MASTER's presence, not how much moved: a change with no
+                                              # UI delta still takes its Change History row, because
+                                              # close-delta stamps the header either way.
+  next: "Delta MERGED into spec.md + design.md, and into design.ui.md where the feature has a UI half (ui_design_updated={{ui_design_exists}} — with a UI delta present that is a full merge, without one it is the Change History row that keeps the header close-delta stamps explainable); OKF edges refreshed ({{xref_edge_count}} dep(s)), {{downstream_count}} downstream slice(s) fenced (gate: {{gate_decision}}). Change {{active_change}} is STILL OPEN and the version is still {{version}}. Next: /appweaver analyze-slice — it now reads a master spec that carries this change, and a red result is still recoverable because nothing has been archived. Then /appweaver close-delta archives the change and bumps the version."