aw-spec-cli 0.1.13 → 0.1.15

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

@@ -0,0 +1,945 @@
+# =============================================================================
+# aw-spec-story-plan (orchestrator) — the per-story execution design, BOTH LANES
+#
+# Authors ONE story's ephemeral design as ONE DOCUMENT PER LANE:
+#   stories/<ID>/story-backend-plan.md    the service design  → /appweaver implement
+#   stories/<ID>/story-frontend-plan.md   the UI design       → /appweaver implement-ui
+# Neither is a maintained design: each is designed FROM the current truth every
+# time, left behind (archived with the story) at close, and never merged anywhere.
+# The durable knowledge routes to append-only logs instead:
+#   • adr.md         — each pass PROPOSES ADRs; they are ratified at story close
+#   • interfaces.md  — the SERVICE pass appends published-surface changes here
+#                      (status: proposed; story close verifies them against the
+#                      as-built and flips them to live). The UI pass CONSUMES that
+#                      log — it never publishes into it.
+#
+# ONE COMMAND, TWO DOCUMENTS. One command because everything before the authoring
+# is shared and must not be answered twice: which story, whether its spec is
+# ledgered, whether it has gone stale, and what code already exists. Two documents
+# because the two designs are authored under different rule sets, from different
+# code, and are read by different implement commands — folded into one file, every
+# one of those becomes a section boundary the next reader has to trust. There is no
+# /appweaver story-plan-ui, and there will not be one.
+#
+# LANE SCOPE IS WHAT IS ACTUALLY THERE. A lane is designed when it is DECLARED in
+# stacks.json and has a USABLE feature plan. A declared lane whose plan is missing,
+# or which the spec has moved past, is dropped from THIS RUN and said out loud with
+# its route — it is not a reason to refuse the lane that is ready. The run stops
+# only when NO lane survives, and then the message carries both lanes' reasons.
+#
+# INPUT CHANNELS, each with one job and no overlap:
+#   spec.md              what MUST be (the contract — the only WHAT authority)
+#   backend-plan.md      the FEATURE ARCHITECTURE the service slice sits inside
+#   frontend-plan.md     the FEATURE ARCHITECTURE the UI slice sits inside
+#                        — both binding, and both read ONE WAY: no story pass ever
+#                        writes back, so each feature plan keeps exactly one writer
+#                        (/appweaver plan · /appweaver plan-ui)
+#   OKF code coverage    what IS — the feature's existing code SPLIT BY LANE, its
+#                        drift, its dependencies and its blast radius, plus per-id
+#                        code anchors where a source map exists (concept-coverage)
+#   constitution + rules what must ALWAYS hold (standards, via tech-select)
+#   adr.md               what was DECIDED and why (binding unless superseded)
+#   interfaces.md        what is PUBLISHED (superseded only by new proposed entries)
+# The feature blueprint is deliberately NOT an input — it is a read-only render for
+# humans; coherence flows through the logs and the code, never through it.
+#
+# THE DESIGN IS YOURS TO EDIT BEFORE YOU BUILD. Each document is a plain markdown
+# file, and a hand edit to its latest pass is what implement then builds. Re-running
+# story-plan does not overwrite that edit: every run APPENDS a
+# "## Design pass N — <date> (spec vX)" section under a SCRIPT-written header, so
+# edit to adjust and re-run to redesign. THE LATEST PASS WINS; earlier passes are
+# the iteration history. Pass numbers are per lane, so designing one lane leaves the
+# other's history untouched. Writing into stories/<ID>/ is what flips the story
+# IN-FLIGHT (sync-stories' isdir test) and drives follow-on minting — the documents
+# must live nowhere else.
+#
+# RULE SETS ARE LOADED PER LANE, IN LANE ORDER — the service rules
+# (## /aw-spec-plan) before the service pass, the UI rules (## /aw-spec-plan-ui)
+# before the UI pass. The engine's standards set is sticky and cumulative, so the UI
+# pass also carries the service rules where both lanes run. That direction is the
+# deliberate one: a UI author reading service layering rules is noise, while a
+# service author reading component and styling rules is misdirection.
+#
+# GATES (all loud, all before any write): at least one lane declared in stacks.json;
+# active feature + spec.md present; the spec-check ledger tripwire (no design from
+# an unledgered spec); per-lane plan freshness (fresh/behind/edited_behind/untracked
+# drop that lane and name the fix; a hand edit still in step is announced in the
+# pass, not refused); the story exists and is OPEN (closed/cancelled/draft each get
+# their own message). A stale story (ledger rows above its stamp naming ids it
+# carries — exercises AND its Constraints section) is announced in the pass, not
+# refused: a declined sync-stories rewrite is a legitimate author decision.
+#
+# Launch:  /appweaver story-plan [<story-id>] [guidance]     (asks when ambiguous)
+# Prereq:  /appweaver plan and/or /appweaver plan-ui (the feature plans this slices)
+#          + a story (specify/sync-stories mint them)  ·  Next: implement · implement-ui
+# =============================================================================
+
+name: aw-spec-story-plan
+description: "Author or extend ONE story's ephemeral execution design, one document per lane — stories/<ID>/story-backend-plan.md and stories/<ID>/story-frontend-plan.md. Each run APPENDS a dated design pass per lane in scope (script-numbered; the latest pass wins, and a manual edit to the latest pass is what implement builds) designed from the current spec, that lane's binding feature plan (read one way — a story pass never writes back), the feature's lane-split OKF code coverage, the technical standards, and the feature's append-only ADR + interface logs. A lane is designed when it is declared AND has a usable plan; a lane whose plan is missing or behind the spec is dropped from the run and said out loud, and the run stops only when no lane survives. The service pass appends published-surface changes to interfaces.md as proposed entries; the UI pass consumes that log. Refuses non-open stories; announces (never hides) a spec that moved above the story's stamp."
+version: 2.0.0
+agent_agnostic: true
+dialect: aw-spec.orchestrator/v1
+
+inputs:
+  user_input:
+    description: Optional story id and/or design guidance (e.g. "Payment-003 keep the dedupe table in-process").
+    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. The TECHNICAL rule
+# files are CONFIGURATION, loaded per lane from tech-rule-bindings.md — the service
+# pass under "## /aw-spec-plan" and the UI pass under "## /aw-spec-plan-ui". Each
+# story design applies the SAME HOW rules as the feature plan it slices, so both
+# reuse their lane's existing slot rather than minting a new one.
+standards:
+  - { path: .appweaver/ai-rules.md }
+
+vars:
+  # lane declaration + lane scope (declared AND usably planned)
+  lanes_declared: "false"
+  be_declared: "false"
+  fe_declared: "false"
+  be_in_scope: "false"
+  fe_in_scope: "false"
+  have_lane: "false"
+  have_design_lane: "false"
+  lane_gate_msg: "No lane is declared in .appweaver/stacks.json, so there is nothing to design this story against. Run /appweaver select-stack and declare the stack(s) plus their source paths, then re-run story-plan."
+  # feature + spec
+  feature_dir: ""
+  spec_file: ""
+  spec_exists: "false"
+  be_plan: ""
+  fe_plan: ""
+  spec_ok: "false"
+  spec_state: ""
+  # per-lane feature-plan freshness (the one-way coupling: a story pass READS a plan)
+  be_plan_state: ""
+  be_plan_derived: ""
+  be_plan_changed: ""
+  be_plan_note: ""
+  be_drop_msg: ""
+  be_dropped: "false"
+  drops_note: "none — every declared lane was designed this run"
+  fe_plan_state: ""
+  fe_plan_derived: ""
+  fe_plan_changed: ""
+  fe_plan_note: ""
+  fe_drop_msg: ""
+  fe_dropped: "false"
+  # story-plan-check bindings
+  any_open: "false"
+  open_ids: "[]"
+  open_ids_csv: ""
+  digest: ""
+  resolved: "false"
+  needs_pick: "false"
+  pick_reason: ""
+  story: ""
+  story_path: ""
+  story_open: "false"
+  status_msg: ""
+  story_title: ""
+  exercises_csv: ""
+  constraints_csv: ""
+  story_spec_version: ""
+  current_version: ""
+  stale_csv: ""
+  stale_note: ""
+  story_dir: ""
+  legacy_doc: ""
+  legacy_doc_exists: "false"
+  be_doc_path: ""
+  be_doc_exists: "false"
+  be_next_pass: "1"
+  be_pass_tmp: ""
+  fe_doc_path: ""
+  fe_doc_exists: "false"
+  fe_next_pass: "1"
+  fe_pass_tmp: ""
+  if_tmp: ""
+  adr_path: ""
+  if_path: ""
+  picked_story: ""
+  # OKF code coverage (the feature's current code, per lane)
+  okf_concept: ""
+  coverage_digest: ""
+  be_source_csv: ""
+  be_source_count: "0"
+  fe_source_csv: ""
+  fe_source_count: "0"
+  coverage_drift: "0"
+  used_by_csv: ""
+  unanchored_csv: ""
+  source_map: ""
+  # write results
+  be_pass_n: "0"
+  be_created: "false"
+  fe_pass_n: "0"
+  fe_created: "false"
+  if_appended: "0"
+  if_ids_csv: ""
+  if_unknown_csv: ""
+  if_badsup_csv: ""
+  if_ok: "true"
+  if_error: ""
+
+workflow:
+
+  # 1. WHICH LANES EXIST — the DECLARATION in stacks.json, not a directory on disk
+  #    (greenfield designs before the code exists). At least one is required; which
+  #    ones are actually designed is settled by the plan gates in step 4.
+  - 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: be_scope
+    condition: "{{be_declared}} == true"
+    action: set
+    vars: { be_in_scope: "true", have_lane: "true" }
+  - id: fe_scope
+    condition: "{{fe_declared}} == true"
+    action: set
+    vars: { fe_in_scope: "true", have_lane: "true" }
+  - id: require_lane
+    action: verify_context
+    require_true: have_lane
+    on_false: stop
+    on_false_message: "{{lane_gate_msg}}"
+
+  # 2. Active feature + its spec. feature-paths reports both plan paths whether or
+  #    not they exist; step 4 decides what an absence means for that lane.
+  - 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: be_plan,     from: "$.backend_plan_file" }
+      - { name: fe_plan,     from: "$.frontend_plan_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 story-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 first — a story design designs against the contract, and there is none."
+
+  # 3. The spec's ledger tripwire: no design pass from an unledgered spec — every
+  #    pass records the spec version it designed against, and an unledgered edit has
+  #    no version to record.
+  - id: spec_guard_read
+    action: execute_script
+    script: { ref: actions }
+    subcommand: spec-check
+    args: ["--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: spec_ok,    from: "$.ok" }
+      - { name: spec_state, from: "$.state" }
+  - id: spec_guard
+    action: verify_context
+    require_true: spec_ok
+    on_false: stop
+    on_false_message: "spec.md has moved outside the ledger (state: {{spec_state}}). Record what changed in a Change History row (fold it back through the spec workflow), re-run spec-stamp to re-baseline, then re-run story-plan — a design pass derived from an unledgered spec records a baseline the ledger cannot name."
+
+  # 4. THE FEATURE-PLAN GATES, one per declared lane. A story design is a SLICE of
+  #    the feature's architecture, so it READS that lane's plan and NEVER writes
+  #    back. The freshness check stops a slice inheriting an architecture the spec
+  #    has already moved past while the script-written pass header stamps the CURRENT
+  #    spec version over it — the pass would read as designed against a spec the plan
+  #    never saw.
+  #
+  #    A FAILING GATE DROPS ITS LANE, IT DOES NOT STOP THE RUN. Missing, behind,
+  #    edited_behind and untracked all mean the same thing — this lane has no usable
+  #    architecture right now — and none of them make the OTHER lane's design wrong.
+  #    Each drop is announced with its own route, and the run stops only if both
+  #    lanes are gone. `untracked` drops for the reason it always did: until one
+  #    /appweaver plan run baselines the document this gate cannot tell clean from
+  #    behind, and a gate that cannot tell is worse than one that asks. `edited` is
+  #    admitted and announced INTO the pass — the plan is the architect's document.
+  - id: be_plan_read
+    condition: "{{be_in_scope}} == true"
+    action: execute_script
+    on_error: continue      # a probe that fails binds nothing; the lane stays out of scope ⇒ fails CLOSED
+    script: { ref: actions }
+    subcommand: plan-check
+    args: ["--doc", "{{be_plan}}", "--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: be_plan_state,   from: "$.state" }
+      - { name: be_plan_derived, from: "$.derived_version" }
+      - { name: be_plan_changed, from: "$.changed_csv" }
+  - id: fe_plan_read
+    condition: "{{fe_in_scope}} == true"
+    action: execute_script
+    on_error: continue      # same fail-closed contract as the service probe
+    script: { ref: actions }
+    subcommand: plan-check
+    args: ["--doc", "{{fe_plan}}", "--feature-dir", "{{feature_dir}}"]
+    outputs:
+      - { name: fe_plan_state,   from: "$.state" }
+      - { name: fe_plan_derived, from: "$.derived_version" }
+      - { name: fe_plan_changed, from: "$.changed_csv" }
+
+  # 4a. SERVICE lane verdict. Only `clean` and `edited` keep the lane; every other
+  #     state (including the empty string a crashed probe leaves) drops it.
+  - id: be_drop_default
+    condition: "{{be_in_scope}} == true"
+    action: set
+    vars:
+      be_in_scope: "false"
+      be_dropped: "true"
+      be_drop_msg: "SERVICE lane not designed: backend-plan.md could not be checked against the spec (state: '{{be_plan_state}}'). Run /appweaver plan for this feature, then re-run story-plan."
+  - id: be_keep_clean
+    condition: "{{be_plan_state}} == clean"
+    action: set
+    vars: { be_in_scope: "true", be_dropped: "false", be_drop_msg: "" }
+  - id: be_keep_edited
+    condition: "{{be_plan_state}} == edited"
+    action: set
+    vars:
+      be_in_scope: "true"
+      be_dropped: "false"
+      be_drop_msg: ""
+      be_plan_note: "NOTE — backend-plan.md carries hand edits that /appweaver plan has not baselined. It is still in step with the spec, so it is authoritative here; design to it as it stands."
+  - id: be_msg_fresh
+    condition: "{{be_plan_state}} == fresh"
+    action: set
+    vars: { be_drop_msg: "SERVICE lane not designed: a backend lane is declared but this feature has no backend-plan.md, so there is no feature architecture to slice. Run /appweaver plan — it authors the plan from spec.md and publishes this feature's interfaces, both of which the service design pass reads — then re-run story-plan." }
+  - id: be_msg_behind
+    condition: "{{be_plan_state}} == behind"
+    action: set
+    vars: { be_drop_msg: "SERVICE lane not designed: backend-plan.md derives from spec {{be_plan_derived}} and the spec has moved past it (ids since: {{be_plan_changed}}). Designing a slice against it would inherit an architecture the spec has outrun. Run /appweaver plan to conform it, then re-run story-plan." }
+  - id: be_msg_edited_behind
+    condition: "{{be_plan_state}} == edited_behind"
+    action: set
+    vars: { be_drop_msg: "SERVICE lane not designed: backend-plan.md has been hand-edited AND the spec has moved past it (derived from {{be_plan_derived}}; ids since: {{be_plan_changed}}). Run /appweaver plan with accept_manual: true — it reconciles the edit and the spec change together — then re-run story-plan." }
+  - id: be_msg_untracked
+    condition: "{{be_plan_state}} == untracked"
+    action: set
+    vars: { be_drop_msg: "SERVICE lane not designed: backend-plan.md has no derivation record — a reversed or hand-placed plan that no baseline names, so nothing can say which spec version it matches and this gate cannot tell fresh from stale. Run /appweaver plan once: it reconciles the WHOLE plan to the current spec and baselines it. Then re-run story-plan." }
+
+  # 4b. UI lane verdict — the same contract, routed to the frontend lane's author.
+  - id: fe_drop_default
+    condition: "{{fe_in_scope}} == true"
+    action: set
+    vars:
+      fe_in_scope: "false"
+      fe_dropped: "true"
+      fe_drop_msg: "UI lane not designed: frontend-plan.md could not be checked against the spec (state: '{{fe_plan_state}}'). Run /appweaver plan-ui for this feature, then re-run story-plan."
+  - id: fe_keep_clean
+    condition: "{{fe_plan_state}} == clean"
+    action: set
+    vars: { fe_in_scope: "true", fe_dropped: "false", fe_drop_msg: "" }
+  - id: fe_keep_edited
+    condition: "{{fe_plan_state}} == edited"
+    action: set
+    vars:
+      fe_in_scope: "true"
+      fe_dropped: "false"
+      fe_drop_msg: ""
+      fe_plan_note: "NOTE — frontend-plan.md carries hand edits that /appweaver plan-ui has not baselined. It is still in step with the spec, so it is authoritative here; design to it as it stands."
+  - id: fe_msg_fresh
+    condition: "{{fe_plan_state}} == fresh"
+    action: set
+    vars: { fe_drop_msg: "UI lane not designed: a frontend lane is declared but this feature has no frontend-plan.md, so there is no UI architecture to slice. Run /appweaver plan-ui — it authors the plan from spec.md and the published interfaces, which the UI design pass reads — then re-run story-plan." }
+  - id: fe_msg_behind
+    condition: "{{fe_plan_state}} == behind"
+    action: set
+    vars: { fe_drop_msg: "UI lane not designed: frontend-plan.md derives from spec {{fe_plan_derived}} and the spec has moved past it (ids since: {{fe_plan_changed}}). Run /appweaver plan-ui to conform it, then re-run story-plan." }
+  - id: fe_msg_edited_behind
+    condition: "{{fe_plan_state}} == edited_behind"
+    action: set
+    vars: { fe_drop_msg: "UI lane not designed: frontend-plan.md has been hand-edited AND the spec has moved past it (derived from {{fe_plan_derived}}; ids since: {{fe_plan_changed}}). Run /appweaver plan-ui with accept_manual: true, then re-run story-plan." }
+  - id: fe_msg_untracked
+    condition: "{{fe_plan_state}} == untracked"
+    action: set
+    vars: { fe_drop_msg: "UI lane not designed: frontend-plan.md has no derivation record — a reversed or hand-placed plan that no baseline names, so this gate cannot tell fresh from stale. Run /appweaver plan-ui once to reconcile and baseline it, then re-run story-plan." }
+
+  # 4c. At least one lane must survive. When none does, BOTH reasons travel in the
+  #     stop message — a run that reported only the first would send the author back
+  #     for a second refusal.
+  - id: have_be
+    condition: "{{be_in_scope}} == true"
+    action: set
+    vars: { have_design_lane: "true" }
+  - id: have_fe
+    condition: "{{fe_in_scope}} == true"
+    action: set
+    vars: { have_design_lane: "true" }
+  - id: require_design_lane
+    action: verify_context
+    require_true: have_design_lane
+    on_false: stop
+    on_false_message: |
+      No lane has a usable feature plan, so there is nothing to design this story against.
+
+      {{be_drop_msg}}
+
+      {{fe_drop_msg}}
+
+  # 4d. What the run did NOT design, in one line for the outputs. Both branches
+  #     compose the same expression: either message is empty when its lane is fine,
+  #     so one set covers a drop on either lane or on both.
+  - id: drops_note_be
+    condition: "{{be_dropped}} == true"
+    action: set
+    vars: { drops_note: "{{be_drop_msg}} {{fe_drop_msg}}" }
+  - id: drops_note_fe
+    condition: "{{fe_dropped}} == true"
+    action: set
+    vars: { drops_note: "{{be_drop_msg}} {{fe_drop_msg}}" }
+
+  # 5. WHICH STORY. The check resolves an explicit id in the input; anything else
+  #    (nothing named, an unknown id, several ids) becomes a pick from the open
+  #    backlog. All state the gates below read comes back in one scan, including
+  #    both lanes' document and pass state.
+  - id: story_scan
+    action: execute_script
+    script: { ref: actions }
+    subcommand: story-plan-check
+    args: ["--feature-dir", "{{feature_dir}}", "--input", "{{USER_INPUT}}"]
+    outputs:
+      - { name: any_open,           from: "$.any_open" }
+      - { name: open_ids,           from: "$.open_ids" }
+      - { name: open_ids_csv,       from: "$.open_ids_csv" }
+      - { name: digest,             from: "$.digest" }
+      - { name: resolved,           from: "$.resolved" }
+      - { name: needs_pick,         from: "$.needs_pick" }
+      - { name: pick_reason,        from: "$.pick_reason" }
+      - { name: story,              from: "$.story" }
+      - { name: story_path,         from: "$.story_path" }
+      - { name: story_open,         from: "$.story_open" }
+      - { name: status_msg,         from: "$.status_msg" }
+      - { name: story_title,        from: "$.story_title" }
+      - { name: exercises_csv,      from: "$.exercises_csv" }
+      - { name: constraints_csv,    from: "$.constraints_csv" }
+      - { name: story_spec_version, from: "$.story_spec_version" }
+      - { name: current_version,    from: "$.current_version" }
+      - { name: stale_csv,          from: "$.stale_csv" }
+      - { name: stale_note,         from: "$.stale_note" }
+      - { name: story_dir,          from: "$.story_dir" }
+      - { name: legacy_doc,         from: "$.legacy_doc" }
+      - { name: legacy_doc_exists,  from: "$.legacy_doc_exists" }
+      - { name: be_doc_path,        from: "$.be_doc_path" }
+      - { name: be_doc_exists,      from: "$.be_doc_exists" }
+      - { name: be_next_pass,       from: "$.be_next_pass" }
+      - { name: be_pass_tmp,        from: "$.be_pass_tmp" }
+      - { name: fe_doc_path,        from: "$.fe_doc_path" }
+      - { name: fe_doc_exists,      from: "$.fe_doc_exists" }
+      - { name: fe_next_pass,       from: "$.fe_next_pass" }
+      - { name: fe_pass_tmp,        from: "$.fe_pass_tmp" }
+      - { name: if_tmp,             from: "$.if_tmp" }
+      - { name: adr_path,           from: "$.adr_path" }
+      - { name: if_path,            from: "$.if_path" }
+  - id: require_open_backlog
+    action: verify_context
+    require_true: any_open
+    on_false: stop
+    on_false_message: "No open stories for this feature — there is nothing to design. Stories are minted by /appweaver specify (bootstrap) and /appweaver sync-stories (when the spec moves)."
+  - id: ask_story
+    condition: "{{needs_pick}} == true"
+    action: ask
+    prompt: |
+      Which story is this design pass for? ({{pick_reason}})
+
+      {{digest}}
+    options_from: "{{open_ids}}"
+    answer_key: picked_story
+    answer_var: picked_story
+  - id: story_pick_check
+    condition: "{{needs_pick}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: story-plan-check
+    args: ["--feature-dir", "{{feature_dir}}", "--story", "{{picked_story}}"]
+    outputs:
+      - { name: resolved,           from: "$.resolved" }
+      - { name: story,              from: "$.story" }
+      - { name: story_path,         from: "$.story_path" }
+      - { name: story_open,         from: "$.story_open" }
+      - { name: status_msg,         from: "$.status_msg" }
+      - { name: story_title,        from: "$.story_title" }
+      - { name: exercises_csv,      from: "$.exercises_csv" }
+      - { name: constraints_csv,    from: "$.constraints_csv" }
+      - { name: story_spec_version, from: "$.story_spec_version" }
+      - { name: stale_csv,          from: "$.stale_csv" }
+      - { name: stale_note,         from: "$.stale_note" }
+      - { name: story_dir,          from: "$.story_dir" }
+      - { name: legacy_doc,         from: "$.legacy_doc" }
+      - { name: legacy_doc_exists,  from: "$.legacy_doc_exists" }
+      - { name: be_doc_path,        from: "$.be_doc_path" }
+      - { name: be_doc_exists,      from: "$.be_doc_exists" }
+      - { name: be_next_pass,       from: "$.be_next_pass" }
+      - { name: be_pass_tmp,        from: "$.be_pass_tmp" }
+      - { name: fe_doc_path,        from: "$.fe_doc_path" }
+      - { name: fe_doc_exists,      from: "$.fe_doc_exists" }
+      - { name: fe_next_pass,       from: "$.fe_next_pass" }
+      - { name: fe_pass_tmp,        from: "$.fe_pass_tmp" }
+      - { name: if_tmp,             from: "$.if_tmp" }
+  - id: require_story
+    action: verify_context
+    require_true: resolved
+    on_false: stop
+    on_false_message: |
+      Could not resolve a story from '{{picked_story}}'. Open stories:
+      {{digest}}
+      Re-run story-plan naming one of them.
+  - id: require_open_story
+    action: verify_context
+    require_true: story_open
+    on_false: stop
+    on_false_message: "{{status_msg}}"
+
+  # 5a. A dropped lane is announced HERE — after the story is known, so the notice
+  #     names the story it applies to, and before any write, so the author can stop
+  #     and fix the plan rather than discovering the gap after a pass has landed.
+  - id: be_drop_notice
+    condition: "{{be_dropped}} == true"
+    action: verify_context
+    require_value: be_dropped
+    equals: "false"
+    on_mismatch: continue
+    on_mismatch_message: "{{be_drop_msg}}"
+  - id: fe_drop_notice
+    condition: "{{fe_dropped}} == true"
+    action: verify_context
+    require_value: fe_dropped
+    equals: "false"
+    on_mismatch: continue
+    on_mismatch_message: "{{fe_drop_msg}}"
+
+  # 5b. A pre-split story-plan.md beside the story is REPORTED, never read and never
+  #     written. Silently leaving it there would leave a design document nobody
+  #     consumes sitting beside two that are read — and the next person to open the
+  #     story directory has no way to tell which of the three implement builds from.
+  - id: legacy_doc_notice
+    condition: "{{legacy_doc_exists}} == true"
+    action: verify_context
+    require_value: legacy_doc_exists
+    equals: "false"
+    on_mismatch: continue
+    on_mismatch_message: "{{legacy_doc}} is a story design from before the lane split. Nothing reads it any more — the service design now lives in story-backend-plan.md and the UI design in story-frontend-plan.md. Fold anything still worth keeping into this run's pass and delete it, or leave it as history; it will not reach implement either way."
+
+  # 6. THE FEATURE'S CODE, from its OKF concept — what IS, split by lane, with the
+  #    drift, the dependencies and the blast radius a bare path list drops. Advisory:
+  #    a greenfield feature has no concept yet and designs from an empty current
+  #    state, so a missing bundle must never block the design. --ids reports which of
+  #    the story's requirements already have a code anchor where the feature carries
+  #    a source map; where it does not, every id comes back unanchored and the digest
+  #    says so rather than implying the code is absent.
+  - id: coverage
+    action: execute_script
+    on_error: continue
+    script: { ref: xref }
+    subcommand: concept-coverage
+    args: ["--feature-dir", "{{feature_dir}}", "--ids", "{{exercises_csv}}"]
+    outputs:
+      - { name: okf_concept,      from: "$.concept" }
+      - { name: coverage_digest,  from: "$.digest" }
+      - { name: be_source_csv,    from: "$.backend_csv" }
+      - { name: be_source_count,  from: "$.backend_count" }
+      - { name: fe_source_csv,    from: "$.frontend_csv" }
+      - { name: fe_source_count,  from: "$.frontend_count" }
+      - { name: coverage_drift,   from: "$.missing_count" }
+      - { name: used_by_csv,      from: "$.used_by_csv" }
+      - { name: unanchored_csv,   from: "$.unanchored_csv" }
+      - { name: source_map,       from: "$.source_map" }
+  - id: drift_notice
+    condition: "{{coverage_drift}} != 0"
+    action: verify_context
+    require_value: coverage_drift
+    equals: "0"
+    on_mismatch: continue
+    on_mismatch_message: "The OKF concept for this feature declares {{coverage_drift}} source file(s) that are not on disk — a file moved or deleted without the owning slice being re-run. The design pass reads only what exists, so the index, not the design, is what is wrong. The drifted paths are named in the coverage block; /appweaver analyze-slice or the next implement on that slice re-writes the list."
+
+  # 7. Pre-execution hooks.
+  - id: resolve_pre_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "before_story_plan"]
+    outputs:
+      - { name: before_hooks, from: "$.hooks" }
+  - id: dispatch_pre_hooks
+    action: dispatch_hooks
+    hooks_from_variable: before_hooks
+
+  # ════════════════════ THE SERVICE DESIGN (payload-only + Read) ═══════════════
+  # Lane rules first, then the pass. The doc itself is in context on a re-run
+  # (optional — absent before pass 1), so a later pass SEES earlier passes and any
+  # manual edits instead of contradicting them blind. Code arrives as a PATH LIST;
+  # the step declares Read to open it.
+  - id: tech_select_be
+    condition: "{{be_in_scope}} == true"
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-plan }
+
+  - id: ctx_be
+    condition: "{{be_in_scope}} == true"
+    action: build_context
+    vars:
+      story_id: "{{story}}"
+      story_title: "{{story_title}}"
+      exercises_csv: "{{exercises_csv}}"
+      constraints_csv: "{{constraints_csv}}"
+      spec_current_version: "{{current_version}}"
+      stale_note: "{{stale_note}}"
+      pass_number: "{{be_next_pass}}"
+      coverage_digest: "{{coverage_digest}}"
+      source_files_csv: "{{be_source_csv}}"
+      source_file_count: "{{be_source_count}}"
+      feature_plan_note: "{{be_plan_note}}"
+      ui_lane_note: "{{fe_drop_msg}}"
+      guidance: "{{USER_INPUT}}"
+    context:
+      - { path: "{{story_path}}" }                   # the slice: exercises, Constraints, Acceptance
+      - { path: "{{spec_file}}" }                    # the contract — the only WHAT authority
+      - { path: "{{feature_dir}}/backend-plan.md" }  # the feature architecture this slice sits inside (READ-ONLY)
+      - { path: "{{be_doc_path}}", optional: true }  # earlier service passes + manual edits (pass 2+)
+      - { path: "{{adr_path}}", optional: true }     # ratified decisions — binding unless superseded
+      - { path: "{{if_path}}", optional: true }      # the published surface (latest entry per id wins)
+      - { path: "{{okf_concept}}", optional: true }  # the feature's OKF concept (use-case log, source map)
+      - { path: .appweaver/memory/constitution.technical.md, optional: true }
+  - id: gen_be
+    condition: "{{be_in_scope}} == true"
+    action: agent_author
+    tools: Read   # the current code arrives as {{source_files_csv}} paths, not inlined
+    output_target: { type: file, path: "{{be_pass_tmp}}" }
+    task: |
+      Write SERVICE design pass {{pass_number}} for story {{story_id}} — {{story_title}}.
+      Output the PASS BODY ONLY: no "## Design pass" header (the script writes and
+      numbers it), no version numbers, no dates. Guidance: {{guidance}}
+
+      SCOPE — the story's ids and NOTHING else: it delivers {{exercises_csv}} and
+      must satisfy {{constraints_csv}}. Resolve every id's wording from spec.md in
+      context. Design work serving any other requirement is overreach — if touching
+      shared structure is genuinely unavoidable, name it under "### Risks & out of
+      scope" with the reason; do not design it here.
+
+      THIS IS THE SERVICE LANE ONLY. Screens, components, client state and styling
+      are the UI design's subject and are written to a separate document. Where the
+      slice has a user-facing surface, design the CONTRACT that serves it — the
+      endpoint or event and its shape — and stop there.
+      {{ui_lane_note}}
+
+      WHAT ALREADY EXISTS — the feature's code coverage, read from its OKF concept.
+      The BACKEND list is yours; the FRONTEND list is there so you do not design a
+      contract that ignores the client that already calls one.
+
+      {{coverage_digest}}
+
+      AUTHORITY, per input channel — on a conflict, stop at the defect, never pick
+      silently:
+      - spec.md is the ONLY authority for WHAT. A contradiction between spec and
+        story wording is a defect: flag it in the pass and design to the spec.
+      - The CURRENT CODE is the authority for what exists. Read the service files
+        listed here ({{source_file_count}} on disk); an empty list means greenfield —
+        say so in "### Current state" and design from a clean slate.
+          {{source_files_csv}}
+      - backend-plan.md is the FEATURE ARCHITECTURE this slice sits inside, and it
+        is BINDING: design within its layering, its ports and use-cases (§2), its
+        published surface (§3) and its cross-cutting decisions (§5). This pass reads
+        it ONE WAY — it NEVER writes back, and nothing here merges into it. Where the
+        slice genuinely cannot fit the plan, say so under "### Risks & out of scope"
+        and stop at the defect; the route is to change the spec and re-run
+        /appweaver plan, never to design around the plan here.
+        {{feature_plan_note}}
+      - The constitution and loaded technical rules are STANDARDS — non-negotiable.
+      - adr.md entries are DECIDED — follow them, or propose a superseding ADR under
+        "### Proposed ADRs" with the trade-off; never silently deviate.
+      - interfaces.md is the PUBLISHED surface — the latest entry per id is the
+        contract. Changing one means a superseding proposed entry, described under
+        "### Interfaces".
+      {{stale_note}}
+
+      STRUCTURE — exactly these subsections, in this order:
+      ### Scope           — the ids and the story's acceptance, one line each, resolved
+                            from the spec (cite ids; never restate spec wording at length)
+      ### Current state   — what the service code has today that this slice touches
+                            (file-level, from the coverage above; "greenfield — no code
+                            yet" when the backend list is empty)
+      ### Approach        — the implementation strategy and WHY it fits the standards
+                            and ADRs; concrete, this is the bridge to real code
+      ### Changes         — file-by-file: each file to create or modify and what
+                            changes in it (signatures, wiring, migrations)
+      ### Interfaces      — published-surface changes in prose (endpoint/event, shape,
+                            what it serves, what it supersedes) — or "None."
+      ### Tests           — what proves the acceptance criteria, named per criterion
+      ### Proposed ADRs   — ONLY a deliberate choice among rule-compliant alternatives,
+                            a rejected alternative with the reason, or a trade-off with
+                            its revisit trigger. Never restate what code shows or a rule
+                            mandates. "None." when there is nothing durable to record.
+      ### Risks & out of scope — divergences flagged above, unavoidable shared-structure
+                            touches, what this slice deliberately leaves out
+
+      This pass is EPHEMERAL scaffolding — it is archived with the story, never
+      merged anywhere. Be concrete and name real paths, classes and signatures; a
+      later pass supersedes this one wholesale, so write nothing here that must
+      outlive the story (that is what the ADR and interface logs are for). Do not
+      write the story id into the body — the document's directory is its identity.
+
+  # 8. APPEND — story-plan-doc is the only writer of either lane's design.
+  #    Script-owned header ("## Design pass N — <date> (spec vX)"), frontmatter
+  #    stamps, temp file removed. Creating the first document in stories/<ID>/ is
+  #    what flips the story in-flight.
+  - id: append_be
+    condition: "{{be_in_scope}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: story-plan-doc
+    args: ["--feature-dir", "{{feature_dir}}", "--story", "{{story}}", "--lane", "backend", "--pass-file", "{{be_pass_tmp}}", "--spec-version", "{{current_version}}"]
+    outputs:
+      - { name: be_pass_n,  from: "$.pass" }
+      - { name: be_created, from: "$.created" }
+
+  # ═══════════════ THE INTERFACE ENTRIES (payload-only, from the doc) ══════════
+  # Formalise the SERVICE pass's "### Interfaces" into append-only log entries.
+  # Separate step so the script stays the only id authority: entries arrive as
+  # IF-NEW blocks and log-append assigns IF-nnn, the date and status: proposed.
+  # The UI lane never runs this — it consumes the log, it does not publish into it.
+  - id: ctx_if
+    condition: "{{be_in_scope}} == true"
+    action: build_context
+    vars:
+      pass_number: "{{be_pass_n}}"
+      exercises_csv: "{{exercises_csv}}"
+    context:
+      - { path: "{{be_doc_path}}" }                  # the service design, latest pass included
+      - { path: "{{if_path}}", optional: true }      # existing entries — what a change supersedes
+  - id: gen_if
+    condition: "{{be_in_scope}} == true"
+    action: agent_author
+    output_target: { type: file, path: "{{if_tmp}}" }
+    task: |
+      From "## Design pass {{pass_number}}" (the LAST pass) of the service story
+      design in context, extract its "### Interfaces" section into formal
+      interface-log entries.
+
+      THE FEATURE PLAN PUBLISHED THE SURFACE ALREADY. /appweaver plan writes this
+      feature's endpoints, events and external contracts into the log when it
+      authors or conforms backend-plan.md, so most passes have nothing to add here.
+      Output an entry ONLY where this slice CHANGES the published surface — a new
+      interface the log does not carry, or one it carries that this pass designs
+      differently (a SUPERSEDING entry naming the id it replaces). An interface the
+      log already carries unchanged is NOT re-published: a second entry saying the
+      same thing splits one contract in two.
+
+      If that section says None, describes no published-surface change (an endpoint,
+      event, or contract consumed outside this service), or describes only what the
+      log already carries — output exactly:
+      none
+
+      Otherwise output ONE block per changed interface, nothing else:
+
+      ## IF-NEW — <METHOD /route, or the event name>
+
+      serves: <the FR-/BR- ids from {{exercises_csv}} this interface exists for>
+      supersedes: <the IF-nnn id it replaces from the interface log in context, or none>
+
+      <a concise request/response or payload sketch — shapes, not implementations>
+
+      Every block starts with "## IF-NEW — " exactly: the script assigns real ids,
+      the date and status: proposed. Entries are proposals against the as-built
+      check at story close — describe the surface the pass actually designed, and
+      invent nothing the pass does not contain.
+  - id: append_if
+    condition: "{{be_in_scope}} == true"
+    action: execute_script
+    on_error: continue   # a malformed extraction is refused LOUDLY but must not burn
+                         # the pass that already landed: the temp file survives for a
+                         # hand-run of log-append; if_error carries the refusal below
+    script: { ref: actions }
+    subcommand: log-append
+    args: ["--feature-dir", "{{feature_dir}}", "--log", "interfaces", "--entries-file", "{{if_tmp}}"]
+    outputs:
+      - { name: if_ok,          from: "$.ok" }
+      - { name: if_error,       from: "$.error" }
+      - { name: if_appended,    from: "$.appended" }
+      - { name: if_ids_csv,     from: "$.ids_csv" }
+      - { name: if_unknown_csv, from: "$.unknown_ids_csv" }
+      - { name: if_badsup_csv,  from: "$.bad_supersedes_csv" }
+
+  # ══════════════════════ THE UI DESIGN (payload-only + Read) ══════════════════
+  # The UI lane's rules load here, AFTER the service pass has been written, so a
+  # service author is never handed component and styling rules. The pass reads the
+  # service story design of the SAME story where there is one: that document, not a
+  # guess, is what this slice's screens bind to.
+  - id: tech_select_fe
+    condition: "{{fe_in_scope}} == true"
+    action: include
+    module: .appweaver/orchestrator/modules/tech-select.orch.yaml
+    with: { command: aw-spec-plan-ui }
+
+  - id: ctx_fe
+    condition: "{{fe_in_scope}} == true"
+    action: build_context
+    vars:
+      story_id: "{{story}}"
+      story_title: "{{story_title}}"
+      exercises_csv: "{{exercises_csv}}"
+      constraints_csv: "{{constraints_csv}}"
+      spec_current_version: "{{current_version}}"
+      stale_note: "{{stale_note}}"
+      pass_number: "{{fe_next_pass}}"
+      coverage_digest: "{{coverage_digest}}"
+      ui_source_files_csv: "{{fe_source_csv}}"
+      ui_source_file_count: "{{fe_source_count}}"
+      feature_plan_note: "{{fe_plan_note}}"
+      service_lane_note: "{{be_drop_msg}}"
+      guidance: "{{USER_INPUT}}"
+    context:
+      - { path: "{{story_path}}" }                    # the slice: exercises, Constraints, Acceptance
+      - { path: "{{spec_file}}" }                     # the contract — the only WHAT authority
+      - { path: "{{feature_dir}}/frontend-plan.md" }  # the UI architecture this slice sits inside (READ-ONLY)
+      - { path: "{{fe_doc_path}}", optional: true }   # earlier UI passes + manual edits (pass 2+)
+      - { path: "{{be_doc_path}}", optional: true }   # this story's service design — what these screens bind to
+      - { path: "{{adr_path}}", optional: true }      # ratified decisions — binding unless superseded
+      - { path: "{{if_path}}", optional: true }       # the published surface this slice CONSUMES
+      - { path: "{{okf_concept}}", optional: true }   # the feature's OKF concept (use-case log, source map)
+      - { path: .appweaver/memory/constitution.ui.md, optional: true }
+  - id: gen_fe
+    condition: "{{fe_in_scope}} == true"
+    action: agent_author
+    tools: Read   # the current UI code arrives as {{ui_source_files_csv}} paths, not inlined
+    output_target: { type: file, path: "{{fe_pass_tmp}}" }
+    task: |
+      Write UI design pass {{pass_number}} for story {{story_id}} — {{story_title}}.
+      Output the PASS BODY ONLY: no "## Design pass" header (the script writes and
+      numbers it), no version numbers, no dates. Guidance: {{guidance}}
+
+      SCOPE — the story's ids and NOTHING else: it delivers {{exercises_csv}} and
+      must satisfy {{constraints_csv}}, of which the UX- constraints are yours to
+      realise. Resolve every id's wording from spec.md in context. Design work
+      serving any other requirement is overreach — if touching a shared shell,
+      layout or design-system component is genuinely unavoidable, name it under
+      "### Risks & out of scope" with the reason; do not design it here.
+
+      THIS IS THE UI LANE ONLY. Persistence, domain rules, service layering and
+      server-side validation belong to the service design and are written to a
+      separate document. Where this slice needs behaviour from the service, bind to
+      the PUBLISHED CONTRACT and stop there.
+      {{service_lane_note}}
+
+      WHAT ALREADY EXISTS — the feature's code coverage, read from its OKF concept.
+      The FRONTEND list is yours; the BACKEND list is there so you bind to code that
+      exists rather than to an endpoint nobody wrote.
+
+      {{coverage_digest}}
+
+      AUTHORITY, per input channel — on a conflict, stop at the defect, never pick
+      silently:
+      - spec.md is the ONLY authority for WHAT. A contradiction between spec and
+        story wording is a defect: flag it in the pass and design to the spec.
+      - The CURRENT CODE is the authority for what exists. Read the UI files listed
+        here ({{ui_source_file_count}} on disk); an empty list means this slice has
+        no UI yet — say so in "### Current state" and design from a clean slate.
+          {{ui_source_files_csv}}
+      - frontend-plan.md is the FEATURE'S UI ARCHITECTURE this slice sits inside, and
+        it is BINDING: design within its navigation and screen structure (§1), its
+        client-state placement (§2), its component composition (§3) and its
+        cross-cutting decisions (§6). This pass reads it ONE WAY — it NEVER writes
+        back, and nothing here merges into it. Where the slice genuinely cannot fit
+        the plan, say so under "### Risks & out of scope" and stop at the defect; the
+        route is to change the spec and re-run /appweaver plan-ui, never to design
+        around the plan here.
+        {{feature_plan_note}}
+      - The constitution and loaded technical rules are STANDARDS — non-negotiable.
+      - adr.md entries are DECIDED — follow them, or propose a superseding ADR under
+        "### Proposed ADRs" with the trade-off; never silently deviate.
+      - interfaces.md is the PUBLISHED surface and this lane CONSUMES it: bind to the
+        latest entry per id and INVENT NOTHING. An interface this slice needs that
+        the log does not carry is a DEFECT, not a gap for you to fill — name it under
+        "### Risks & out of scope" with the shape you needed; the route is
+        /appweaver story-plan on the service lane, which publishes it. Where this
+        story's service design is in context, it is the fresher word on what this
+        slice's surface will be — bind to it and say which entry it supersedes.
+      {{stale_note}}
+
+      STRUCTURE — exactly these subsections, in this order:
+      ### Scope             — the ids and the story's acceptance, one line each,
+                              resolved from the spec (cite ids; never restate spec
+                              wording at length)
+      ### Current state     — what the UI code has today that this slice touches
+                              (file-level, from the coverage above; "no UI for this
+                              slice yet" when the frontend list is empty)
+      ### Approach          — routes and screens touched, where the state for this
+                              slice lives and why that placement fits the plan, and
+                              how the slice fits the existing composition
+      ### Screens & components — file-by-file: each component, route, store or style
+                              file to create or modify and what changes in it (props,
+                              state, events)
+      ### Contract binding  — every published interface this slice calls, BY ITS
+                              IF-nnn id, with the request it sends and the response
+                              it renders; and for each one what the user sees while
+                              it is in flight, when it is empty, and when it fails
+      ### Tests             — what proves the acceptance criteria, named per
+                              criterion (component, interaction and accessibility)
+      ### Proposed ADRs     — ONLY a deliberate choice among rule-compliant
+                              alternatives, a rejected alternative with the reason, or
+                              a trade-off with its revisit trigger. Never restate what
+                              code shows or a rule mandates. "None." when there is
+                              nothing durable to record.
+      ### Risks & out of scope — divergences flagged above, contracts this slice needs
+                              that are not published, unavoidable shared-shell
+                              touches, what this slice deliberately leaves out
+
+      This pass is EPHEMERAL scaffolding — it is archived with the story, never
+      merged anywhere. Be concrete and name real paths, components and props; a later
+      pass supersedes this one wholesale, so write nothing here that must outlive the
+      story (that is what the ADR and interface logs are for). Do not write the story
+      id into the body — the document's directory is its identity.
+
+  - id: append_fe
+    condition: "{{fe_in_scope}} == true"
+    action: execute_script
+    script: { ref: actions }
+    subcommand: story-plan-doc
+    args: ["--feature-dir", "{{feature_dir}}", "--story", "{{story}}", "--lane", "frontend", "--pass-file", "{{fe_pass_tmp}}", "--spec-version", "{{current_version}}"]
+    outputs:
+      - { name: fe_pass_n,  from: "$.pass" }
+      - { name: fe_created, from: "$.created" }
+
+  # 9. Post-execution hooks.
+  - id: resolve_post_hooks
+    action: execute_script
+    script: { ref: actions }
+    subcommand: resolve-hooks
+    args: ["--phase", "after_story_plan"]
+    outputs:
+      - { name: after_hooks, from: "$.hooks" }
+  - id: dispatch_post_hooks
+    action: dispatch_hooks
+    hooks_from_variable: after_hooks
+
+outputs:
+  story: "{{story}}"
+  service_design: "{{be_doc_path}} (in scope: {{be_in_scope}}, pass {{be_pass_n}})"
+  ui_design: "{{fe_doc_path}} (in scope: {{fe_in_scope}}, pass {{fe_pass_n}})"
+  lanes_not_designed: "{{drops_note}}"
+  designed_against_spec: "{{current_version}}"
+  designed_within_plans: "backend-plan.md ({{be_plan_state}}, derived from spec {{be_plan_derived}}) · frontend-plan.md ({{fe_plan_state}}, derived from spec {{fe_plan_derived}})"
+  code_coverage: "OKF concept {{okf_concept}} — service {{be_source_count}} file(s), UI {{fe_source_count}} file(s), {{coverage_drift}} declared-but-missing; downstream of this aggregate: [{{used_by_csv}}]"
+  requirements_without_code_anchor: "{{unanchored_csv}} — anchors read from [{{source_map}}]; an EMPTY bracket means this feature carries no requirement-to-code index, so the ids above are unproven either way, not uncovered"
+  stale_ids: "{{stale_csv}}"
+  interfaces_appended: "{{if_ids_csv}}"
+  interface_warnings: "serves ids not in spec: [{{if_unknown_csv}}] · supersedes targets not in log: [{{if_badsup_csv}}] · append refusal: [{{if_error}}] (empty brackets = clean; a refusal keeps the temp entries file beside the doc — fix it and run the log-append action by hand rather than burning a new pass)"
+  next: "THE LATEST PASS WINS, per lane — read '## Design pass {{be_pass_n}}' in the service design and '## Design pass {{fe_pass_n}}' in the UI design; earlier passes are history and manual edits there survive. EDIT EITHER DOCUMENT BEFORE YOU BUILD: implement reads the latest pass as it stands, so a hand correction is honoured; re-run story-plan instead to redesign. Interface entries appended as status:proposed ({{if_ids_csv}}) — story close verifies them against the as-built and flips them live. Proposed ADRs (if any) sit in the passes for ratification into adr.md at story close. stale_ids non-empty means the spec moved above this story's stamp — consider /appweaver sync-stories. Then: /appweaver implement (service) · /appweaver implement-ui (UI)."