aw-spec-cli 0.1.16 → 0.1.18

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

@@ -0,0 +1,535 @@
+# =============================================================================
+# aw-spec-analyze-plan (orchestrator) — the spec↔plan conformance GATE, BOTH LANES
+#
+# The single, discrete conformance gate on the forward path:
+#   specify → plan → analyze-plan → implement.
+#
+# FOUR CHECKS, one per way a plan can be wrong:
+#   1. spec.md → backend-plan.md   — every spec item has a service home
+#   2. spec.md → frontend-plan.md  — every experience item has a screen home
+#   3. backend-plan.md ↔ frontend-plan.md — CONTRACT BINDING: every call the frontend
+#      makes exists in the service's published surface, with the same field shapes. This
+#      is the check neither one-sided pass can make: a frontend call the backend never
+#      defines passes both coverage checks and fails at integration.
+#   4. the plans → domain-model.md — no invented aggregate, no unenforced invariant. The
+#      model is spec-tier and is READ here, never written.
+# Plus the OVERLAY BACKSTOP: the domain gate checklist, as a fifth pass over both plans.
+#
+# WHICH CHECKS RUN COMES FROM stacks.json. A backend-only project runs 1 + 4 (+ backstop);
+# a frontend-only project runs 2 + 4; a full-stack project runs all four. Check 3 needs
+# both plans to exist and is skipped, not failed, when only one lane is declared.
+#
+# THIS STAGE VALIDATES; `plan` AUTHORS. A declared lane whose plan document is MISSING
+# STOPS the run naming /appweaver plan — it is not scaffolded and repaired here. Filling
+# an empty template through a 3-pass repair loop would author a plan without the lane's
+# rule set, without the template selection and without the feature's real source files,
+# which is exactly the work `plan` does properly.
+#
+# BOOTSTRAP-ONLY, and it NEVER opens, merges or closes a change. It gates a feature whose
+# spec.md + lane plans ARE the masters. With a change OPEN the delta docs are the
+# authoritative in-flight edit and the master pair must not be rewritten under them, so
+# the run STOPS and routes to /appweaver analyze-plan-delta (the delta's own gate). The
+# change is closed by close-delta, the SINGLE cr-archive caller, and only after
+# finalize-delta has merged the delta into the masters. Also runnable on demand to
+# re-anchor a hand-edited spec — again, only when no change is open.
+#
+# RENAMED FROM `analyze-design`, following design → plan. It also absorbs the ⌛
+# `analyze-design-ui` phase that was never built as its own command: the frontend lane is
+# checked here, by the same gate, in the same run.
+#
+# Launch:  /appweaver analyze-plan [strategy]
+# Prereq:  /appweaver plan   (a spec.md + one plan document per declared lane).
+# =============================================================================
+
+name: aw-spec-analyze-plan
+description: The spec↔plan conformance gate for every declared lane — confirm backend-plan.md and frontend-plan.md follow spec.md, that they bind to each other's contract, and that neither contradicts the bounded context's domain model (domain overlays are a backstop); with approval, repair the drifting plan. Lanes come from .appweaver/stacks.json, so one command gates backend-only, frontend-only and full-stack projects. Bootstrap-only — with a change open it stops and routes to analyze-plan-delta; it never closes a change.
+version: 3.0.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
+
+standards:
+  - { path: .appweaver/ai-rules.md }   # kit-resident: the universal operating rules, every flow
+
+vars:
+  analyze_ok: "false"
+  active_change: ""
+  has_change: "false"
+  version: ""
+  no_open_change: "true"   # NOT has_change ⇒ the masters are authoritative ⇒ this gate applies
+  lanes_declared: "false"
+  be_declared: "false"
+  fe_declared: "false"
+  # PER-LANE PRESENCE. A lane is CHECKED when it is declared and its plan document is on
+  # disk, and MISSING when it is declared and the document is not. The engine has no
+  # compound conditions, so each AND is one ordered assignment taking the lane's own
+  # `declared` value under the exists/not-exists condition.
+  be_present: "false"
+  fe_present: "false"
+  be_missing: "false"
+  fe_missing: "false"
+  plans_ok: "true"         # every declared lane has its plan ⇒ there is something to gate
+  both_lanes: "false"      # both plans present ⇒ the contract check applies
+  # Which document the repair pass rewrites. Each is raised only when the analyze pass
+  # reported drift IN that lane AND that lane is present.
+  be_repair: "false"
+  fe_repair: "false"
+  backend_repair: "false"
+  frontend_repair: "false"
+  backend_plan: ""
+  frontend_plan: ""
+  # The plan paths AS CONTEXT — bound only for a lane this run actually gates. feature-paths
+  # resolves both paths whatever the declaration says, so putting them straight into the
+  # envelope would show the gate a document belonging to a lane nobody declared: a frontend
+  # plan left behind by a removed lane would still be read, and the checks that skip it
+  # would be contradicted by its presence in the payload. An unbound var renders empty and
+  # the engine drops it.
+  be_plan_ctx: ""
+  fe_plan_ctx: ""
+  domain_model: ""
+
+workflow:
+
+  # 0. WHICH LANES EXIST. The declaration is the same one `plan` wrote against, read the
+  #    same way — lane-resolve, no on-disk check: this gate cares which documents were
+  #    supposed to be authored, not where the code will live.
+  - id: lane_resolve
+    action: execute_script
+    on_error: continue      # never crash raw on an undeclared lane — the gate below explains it
+    script: { ref: actions }
+    subcommand: lane-resolve
+    outputs:
+      - { name: lanes_declared, from: "$.declared" }
+      - { name: be_declared,    from: "$.backend_declared" }
+      - { name: fe_declared,    from: "$.frontend_declared" }
+
+  - id: require_lane
+    action: verify_context
+    require_true: lanes_declared
+    on_false: stop
+    on_false_message: "No lane is declared in .appweaver/stacks.json, so there is no plan to gate. Run /appweaver select-stack and declare the backend stack, the frontend stack, or both, then /appweaver plan, then re-run analyze-plan."
+
+  # 1. Resolve the current feature, its spec and its lane plans. feature-paths resolves a
+  #    legacy design.md / design.ui.md under the plan keys too, so a tree that has not been
+  #    through `plan` since the rename is gated on the document that is actually there.
+  - 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,             from: "$.feature" }
+      - { name: feature_dir,         from: "$.feature_dir" }
+      - { name: spec_file,           from: "$.spec_file" }
+      - { name: spec_exists,         from: "$.spec_exists" }
+      - { name: backend_plan,        from: "$.backend_plan" }
+      - { name: frontend_plan,       from: "$.frontend_plan" }
+      - { name: backend_plan_exists, from: "$.backend_plan_exists" }
+      - { name: frontend_plan_exists, from: "$.frontend_plan_exists" }
+
+  # The BOUNDED CONTEXT's domain model — where the aggregate root, its entities and its
+  # invariants (BR-n) live. The spec cites them by id and the plans record where each is
+  # ENFORCED, so check 4 has nothing to check without it in context.
+  - id: context_paths
+    action: execute_script
+    on_error: continue
+    script: { ref: actions }
+    subcommand: context-paths
+    outputs:
+      - { name: context,             from: "$.context" }
+      - { name: domain_model,        from: "$.domain_model" }
+      - { name: domain_model_exists, from: "$.domain_model_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 analyze-plan."
+
+  - 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 (and /appweaver plan) first."
+
+  # 1b. Read the open change (opened by specify, or by plan on a plan-only change).
+  #     has_change drives the BOOTSTRAP-ONLY guard below — it closes nothing.
+  - 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" }
+
+  # 1c. BOOTSTRAP-ONLY GUARD. A change open ⇒ the delta spec + delta plans are the
+  #     authoritative in-flight edit and this stage is the WRONG gate: its repair loop
+  #     rewrites the MASTER plans, which would drift the masters out from under the delta
+  #     before finalize-delta merges it. Stop BEFORE any authoring so the wrong-stage run
+  #     has zero side effects, and route to the delta's own gate.
+  - id: flag_change_open
+    condition: "{{has_change}} == true"
+    action: set
+    vars: { no_open_change: "false" }
+
+  - id: require_no_change
+    action: verify_context
+    require_true: no_open_change
+    on_false: stop
+    on_false_message: "Change {{active_change}} is OPEN on this feature — analyze-plan is the BOOTSTRAP gate and must not rewrite the master plans while a delta is in flight. Gate the delta instead: /appweaver analyze-plan-delta → implement → build → analyze-slice-delta → finalize-delta (merges the delta into spec.md and domain-model.md — not the lane plans, which are derived from those two) → analyze-slice → close-delta (archives the change + bumps the version). Re-run analyze-plan once every change is closed, to re-anchor the masters."
+
+  # 2. WHICH LANES ARE GATED. Present = declared AND on disk; missing = declared AND not.
+  #    Taking the lane's own `declared` value under the exists condition is how the AND is
+  #    expressed — an UNDECLARED lane's flags stay false either way, which is what makes a
+  #    stray plan document from a lane that was later removed silently ignored rather than
+  #    gated against a stack nobody declared.
+  - id: be_flag_present
+    condition: "{{backend_plan_exists}} == true"
+    action: set
+    vars: { be_present: "{{be_declared}}" }
+  - id: be_flag_missing
+    condition: "{{backend_plan_exists}} == false"
+    action: set
+    vars: { be_missing: "{{be_declared}}" }
+  - id: fe_flag_present
+    condition: "{{frontend_plan_exists}} == true"
+    action: set
+    vars: { fe_present: "{{fe_declared}}" }
+  - id: fe_flag_missing
+    condition: "{{frontend_plan_exists}} == false"
+    action: set
+    vars: { fe_missing: "{{fe_declared}}" }
+
+  # A declared lane with no plan is not a gap this gate repairs — it is work `plan` has
+  # not done. Two independent raises so neither lane can cancel the other's.
+  - id: plans_not_ok_backend
+    condition: "{{be_missing}} == true"
+    action: set
+    vars: { plans_ok: "false" }
+  - id: plans_not_ok_frontend
+    condition: "{{fe_missing}} == true"
+    action: set
+    vars: { plans_ok: "false" }
+
+  - id: require_plans
+    action: verify_context
+    require_true: plans_ok
+    on_false: stop
+    on_false_message: "A declared lane has no plan document (backend declared={{be_declared}} missing={{be_missing}} · frontend declared={{fe_declared}} missing={{fe_missing}}). Run /appweaver plan — it authors each declared lane's plan from the spec, the domain model, that lane's rule set and the feature's real source files. This gate validates a plan; it does not write one."
+
+  # Check 3 needs BOTH documents. One more ordered assignment: with the backend present,
+  # take the frontend's own presence as the answer.
+  - id: flag_both_lanes
+    condition: "{{be_present}} == true"
+    action: set
+    vars: { both_lanes: "{{fe_present}}" }
+
+  # Bind each present lane's plan as a CONTEXT path. A lane that is not gated leaves its
+  # var empty, so its document never reaches the payload.
+  - id: be_ctx_path
+    condition: "{{be_present}} == true"
+    action: set
+    vars: { be_plan_ctx: "{{backend_plan}}" }
+  - id: fe_ctx_path
+    condition: "{{fe_present}} == true"
+    action: set
+    vars: { fe_plan_ctx: "{{frontend_plan}}" }
+
+  # 2b. Load the domain GATE overlays (the domain-rule-bindings `/aw-spec-gate` checklist) as
+  #     the conformance checklist — VALIDATION input only, NEVER authoring. The analyze
+  #     step sees them (include_standards: true); the repair steps do NOT (a plan conforms
+  #     to the SPEC, not to the overlays). Empty/no-op for a non-domain project.
+  - id: resolve_gate_overlays
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-domain
+    args: ["--command", "aw-spec-gate"]
+    outputs:
+      - { name: gate_overlays, from: "$.candidates" }
+  - id: load_gate_overlays
+    action: load_standards
+    files_from_variable: gate_overlays
+    optional: true
+
+  # 3. Pre-execution hooks.
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_analyze"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # 4. THE GATE'S CONTEXT — the anchor, the model and the plans of the lanes being gated.
+  #    A lane that is not gated left its *_plan_ctx var empty, so its document drops out and
+  #    the same envelope serves all three project shapes. It stays the envelope for the
+  #    repair steps too: a repair rewrites one plan against exactly what the check read.
+  - id: ctx_gate
+    action: build_context
+    context:
+      - { path: "{{spec_file}}" }                       # THE ANCHOR
+      - { path: "{{domain_model}}", optional: true }    # spec-tier, READ here and never written
+      - { path: "{{be_plan_ctx}}", optional: true }
+      - { path: "{{fe_plan_ctx}}", optional: true }
+
+  # 5. Conformance + REPAIR loop (spec is the anchor): check → REPORT gaps + ASK →
+  #    Repair on approval → re-check; "Report and Skip" writes plan-analyze-report.md
+  #    and stops. Bounded (3×). The repair is PER LANE, so a frontend drift never
+  #    rewrites a conformant backend plan.
+  - id: analyze_loop
+    action: loop
+    while: "{{analyze_ok}} != true"
+    max_iterations: 3
+    steps:
+      - id: analyze
+        action: agent_query
+        include_standards: true            # the gate overlays (checklist) are in the standards
+        schema: { ok: true, backend_repair: false, frontend_repair: false, gaps: [ { severity: "high", check: "<spec-backend|spec-frontend|contract|model|overlay>", lane: "<backend|frontend>", spec_ref: "<FR/BR/CN/DC/IC/UX/US/SC or overlay or —>", where: "<plan section>", gap: "<how it drifts>" } ] }
+        mock: { ok: true, backend_repair: false, frontend_repair: false, gaps: [] }
+        task: |
+          spec.md is the ANCHOR. Gate this feature's LANE PLANS against it and against the
+          bounded context's domain model, and list EVERY drift as a gap. Run the checks
+          that apply — backend plan present: {{be_present}}, frontend plan present:
+          {{fe_present}}, both present: {{both_lanes}}. A check for an absent lane is
+          SKIPPED, not failed: an undeclared lane is a project decision, not a gap.
+
+          CHECK 1 — spec.md → backend-plan.md (when the backend plan is in context):
+          (a) every spec item — FR / Business Rule / Constraint (CN-) / Data
+          Classification (DC-) / Integration Contract (IC-) / user story / success
+          criterion — has a service home, and the Traceability section is complete. A
+          lifted CN-/DC-/IC- with no plan row is a HIGH gap. EXCEPT the Experience
+          Standards (UX-), which the service plan excludes by contract;
+          (b) NO plan element exceeds or contradicts the spec — anything without a spec
+          basis is a drift unless already logged as a DA-n assumption;
+          (c) the layers are coherent (Application→Domain, API→Application, Infra
+          implements the declared ports) and it stays high-level + technology-agnostic.
+
+          CHECK 2 — spec.md → frontend-plan.md (when the frontend plan is in context):
+          (a) every Experience Standard (UX-) has a home here — the service plan excludes
+          them, so a UX- in neither plan is a DROPPED requirement, a HIGH gap;
+          (b) every user story has a screen and a flow; every interaction-state FR- has a
+          flow row; the interaction-state set (loading, empty, error, permission-denied,
+          in-flight) is present for each interaction it describes;
+          (c) each CN-/DC-/IC-/SC- with an experience obligation is realised (authorization
+          surface, what may not reach the client, binding rows, performance) and the
+          Traceability section is complete;
+          (d) it stays technology-agnostic — no framework, router, state library, component
+          library or styling approach.
+
+          CHECK 3 — CONTRACT BINDING, backend-plan.md ↔ frontend-plan.md (ONLY when
+          {{both_lanes}} is true; skip entirely otherwise). This is the check neither
+          one-sided pass can make:
+          (a) EVERY call, endpoint or payload the frontend plan binds to EXISTS in the
+          service plan's published API surface. One that does not is a HIGH gap on the
+          `contract` check — lane `backend` when the spec requires the capability (the
+          service must publish it), lane `frontend` when the experience invented it;
+          (b) the FIELD SHAPES agree in both directions — a field the frontend reads that
+          the service never returns, and a required field the service demands that the
+          frontend never sends, are both HIGH gaps;
+          (c) anything the frontend plan raised under "Contract deltas needed" is
+          UNRESOLVED by definition: report it as a gap so it is closed here rather than
+          discovered at integration;
+          (d) the frontend plan cites the service's published surface and does NOT restate,
+          re-derive or contradict it, and states no server-side behaviour or persistence
+          assumption.
+
+          CHECK 4 — the plans → domain-model.md (when the model is in context; skip if it
+          is not):
+          (a) the backend plan's DOMAIN layer matches the model EXACTLY — entities and
+          value objects are its aggregate section's entities (SAME names), the boundary is
+          its Boundary block, states are the lifecycle it describes;
+          (b) EVERY invariant (BR-nnn) the spec cites has a named ENFORCEMENT POINT in the
+          backend plan. An invariant nothing enforces is a HIGH gap; a plan that RESTATES
+          what an invariant says instead of citing it by id is a gap too — the model is the
+          only place that text lives;
+          (c) NO aggregate, entity, event or invariant appears in a plan that the model
+          does not define. A plan may not invent domain structure: the fix is
+          /appweaver specify (which authors the model), never the plan;
+          (d) both plans use the model's UBIQUITOUS LANGUAGE — the same terms in names,
+          states, labels and messages, no synonyms.
+
+          CHECK 5 — OVERLAY BACKSTOP. The domain gate checklist is loaded in the standards.
+          For each constraint it states (retention, immutability, append-only audit,
+          data-exposure, interop obligation, etc.), confirm the plans realise it via a spec
+          CN-/DC-/IC-. If a checklist constraint is present in NEITHER the spec nor either
+          plan, it is a HIGH gap — set spec_ref to the overlay name and PREFIX the gap text
+          with "LIFT-FAILURE:" (it was never lifted into the spec; the fix is
+          /appweaver specify, not the plan — do not fabricate it here).
+
+          Tag every gap with its `check` and the `lane` whose document must change to close
+          it. Set backend_repair true if any gap needs the backend plan rewritten, and
+          frontend_repair likewise. (If a plan is still the empty template, treat the WHOLE
+          spec as gaps against it.) Set ok=true ONLY when every applicable check passes and
+          no checklist constraint is unaccounted for.
+        outputs:
+          - { name: analyze_ok,      from: "$.ok" }
+          - { name: analyze_gaps,    from: "$.gaps" }
+          - { name: backend_repair,  from: "$.backend_repair" }
+          - { name: frontend_repair, from: "$.frontend_repair" }
+      - id: conform_break
+        action: break
+        condition: "{{analyze_ok}} == true"
+      - id: ask_repair
+        action: ask
+        prompt: |
+          analyze-plan found spec↔plan gaps (spec.md is the anchor; domain-model.md is
+          read-only here):
+          {{analyze_gaps}}
+          Repair the drifting plan(s) to conform now, or report the gaps and stop?
+        options: ["Repair", "Report and Skip"]
+        answer_var: repair_choice
+      - id: write_report
+        condition: "{{repair_choice}} == Report and Skip"
+        action: agent_author
+        include_standards: false
+        output_target: { type: file, path: "{{feature_dir}}/plan-analyze-report.md" }
+        task: |
+          Write a Plan Analyze Report to the output from these spec↔plan conformance gaps
+          (spec.md is the ANCHOR; the user chose to skip repair):
+          {{analyze_gaps}}
+          Markdown format:
+          - "# Plan Analyze Report — <aggregate>" plus today's date.
+          - A verdict line: "verdict: GAPS ✗ · <n> gap(s)".
+          - "## Gaps" as a table: | # | check | lane | severity | spec ref | plan location | gap |.
+          - "## How to resolve": the spec is the anchor — update the named plan to follow
+            it for each gap (out of band). A `model` gap whose fix is a missing entity or
+            invariant routes to /appweaver specify, which authors domain-model.md; a
+            `contract` gap is closed in the lane the row names. Then re-run
+            /appweaver analyze-plan to clear the report.
+          Return the complete report markdown only.
+      - id: skip_break
+        action: break
+        condition: "{{repair_choice}} == Report and Skip"
+
+      # WHICH DOCUMENT GETS REWRITTEN. A repair runs only where the analyze pass reported
+      # drift in that lane AND that lane is present — two ordered assignments per lane,
+      # cleared first so a lane that was repaired on the previous iteration and is clean
+      # on this one is not rewritten again.
+      - id: be_repair_clear
+        action: set
+        vars: { be_repair: "false" }
+      - id: be_repair_flag
+        condition: "{{backend_repair}} == true"
+        action: set
+        vars: { be_repair: "{{be_present}}" }
+      - id: fe_repair_clear
+        action: set
+        vars: { fe_repair: "false" }
+      - id: fe_repair_flag
+        condition: "{{frontend_repair}} == true"
+        action: set
+        vars: { fe_repair: "{{fe_present}}" }
+
+      - id: repair_backend
+        condition: "{{be_repair}} == true"
+        action: agent_author
+        include_standards: false           # rewrite-in-place: spec anchors — NOT the overlays
+        output_target: { type: file, path: "{{backend_plan}}" }
+        task: |
+          spec.md is the ANCHOR — update backend-plan.md (in context) to CONFORM to it,
+          closing the gaps whose lane is `backend` (the spec WINS every time):
+          {{analyze_gaps}}
+          - Add a plan home for each uncovered spec FR/BR/CN/DC/IC/US/SC (a lifted
+            CN-/DC-/IC- lands in a §1 domain invariant enforcement · the persistence
+            component or an External Integrations table adapter row · a Cross-Cutting
+            Concerns row). UX- items are NOT this document's — leave them to the frontend
+            plan.
+          - Realign the DOMAIN layer to the CONTEXT'S DOMAIN MODEL: entity/value-object
+            names = its entities, the boundary = its Boundary block, and every cited
+            BR-nnn gets a named ENFORCEMENT POINT. Cite invariants by id; never restate
+            what one says. DO NOT EDIT domain-model.md — it is spec-tier and read-only
+            here. If a gap can only be closed by ADDING to the model, you cannot close it:
+            leave it open and add a DA-n saying it routes to /appweaver specify.
+          - CONTRACT gaps whose lane is `backend`: PUBLISH the missing surface in the API
+            section as field shapes, so the frontend plan has something real to bind to.
+          - REMOVE, or move to a DA-n assumption, any plan element with no spec basis —
+            never keep a plan that exceeds or contradicts the spec. EXCEPTION: do NOT
+            remove a cross-cutting element that is (or may be) mandated by the technical
+            constitution — it cites a principle as its basis ("per Const. §<n>"), or it is
+            standing technical/infrastructure machinery rather than invented domain logic.
+            MOVE such an element to a DA-n citing the mandating principle; removing it
+            could violate the constitution. Reserve REMOVE for genuine over-reach —
+            invented domain entities/rules/behaviour the spec omits.
+          - A "LIFT-FAILURE:" gap you CANNOT close — the constraint is not in the spec, and
+            you must NOT invent a domain rule the spec omits. Leave it open and add a DA-n
+            note "lift-failure: <constraint> — re-run /appweaver specify to lift it into
+            CN-/DC-/IC-". (The gate will stop and direct the user to specify.)
+          - Keep the Traceability section in sync. Preserve every already-conformant
+            section VERBATIM. Do NOT change the spec, the domain model or the frontend plan.
+          Return the COMPLETE updated backend-plan.md content only.
+
+      - id: repair_frontend
+        condition: "{{fe_repair}} == true"
+        action: agent_author
+        include_standards: false           # rewrite-in-place: spec anchors — NOT the overlays
+        output_target: { type: file, path: "{{frontend_plan}}" }
+        task: |
+          spec.md is the ANCHOR — update frontend-plan.md (in context) to CONFORM to it,
+          closing the gaps whose lane is `frontend` (the spec WINS every time):
+          {{analyze_gaps}}
+          - Give every uncovered Experience Standard (UX-), user story and
+            interaction-state FR- a home: a screen in the navigation section, a flow row,
+            and the full state set (loading, empty, error, permission-denied, in-flight).
+            UX- items live HERE and nowhere else.
+          - Realise each CN-/DC-/IC-/SC- with an experience obligation, citing its spec id
+            — the authorization surface and access conditions, what may not reach the
+            client or its logs, storage and URLs, the binding rows, the performance row.
+          - CONTRACT gaps whose lane is `frontend`: bind ONLY to the service plan's
+            published surface (in context). CITE it; do not restate, re-derive or
+            contradict it, and introduce NO server-side behaviour or persistence
+            assumption. A capability the experience needs that the surface does not offer
+            stays under "Contract deltas needed" — it is the service lane's to publish,
+            never a client-side workaround.
+          - Use the domain model's UBIQUITOUS LANGUAGE exactly in labels, states and
+            messages, and cite BR-nnn rather than restating a rule. DO NOT EDIT
+            domain-model.md or backend-plan.md.
+          - A state the UI can reach that the spec does not describe is a SPEC gap: log it
+            as a DA-n that routes to /appweaver specify; never invent the requirement here.
+          - Stay TECHNOLOGY-AGNOSTIC: no framework, router, state library, component
+            library or styling approach — responsibilities, field shapes, events and states
+            only.
+          - Keep the Traceability section in sync, both ways. Preserve every
+            already-conformant section VERBATIM.
+          Return the COMPLETE updated frontend-plan.md content only.
+
+  - id: analyze_gate
+    action: verify_context
+    require_true: analyze_ok
+    on_false: stop
+    on_false_message: "The lane plans do not conform to the spec (gaps: {{analyze_gaps}}) — repair was skipped (see plan-analyze-report.md), or it could not be reconciled in 3 passes. A 'LIFT-FAILURE:' gap means a domain constraint from the gate checklist was never lifted into the spec, and a `model` gap means the plan needs an entity or invariant domain-model.md does not define — both are fixed by /appweaver specify, which authors the spec and the model; this gate may not write either. A `contract` gap is closed in the lane its row names. Otherwise fix out of band, or re-run and choose Repair."
+
+  # (No change-close here by design — this stage only ever runs with NO change open,
+  #  and cr-archive belongs to close-delta, which runs after finalize-delta's merge.)
+
+  # 6. Post-execution hooks.
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_analyze"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  feature_dir: "{{feature_dir}}"
+  bounded_context: "{{context}}"
+  backend_plan: "{{backend_plan}}"      # empty when no backend lane is declared
+  frontend_plan: "{{frontend_plan}}"    # empty when no frontend lane is declared
+  domain_model: "{{domain_model}}"
+  conformant: "{{analyze_ok}}"
+  gaps: "{{analyze_gaps}}"
+  version: "{{version}}"
+  note: "Checked: spec→backend-plan ({{be_present}}), spec→frontend-plan ({{fe_present}}), the plan↔plan contract binding ({{both_lanes}} — it needs both lanes) and both plans against domain-model.md. The domain model was READ, never written: a gap that needs a new entity, event or invariant is fixed by /appweaver specify."
+  next: "/appweaver implement   (the plans conform to the spec; version unchanged — this gate closes nothing)"