feat(934): typed Stage enum replaces directory-string state model

The state machine's `Stage` enum becomes the source of truth for pipeline
state. Six stages of work land together:

  1. Clean wire vocabulary (`coding`, `merge`, `merge_failure`, ...) replaces
     legacy directory-style strings (`2_current`, `4_merge`, ...) on the wire.
     `Stage::from_dir` accepted both during deployment; new writes always
     emit the clean form via `stage_dir_name`. Lexicographic `dir >= "5_done"`
     checks in lifecycle.rs become typed `matches!` checks since the new
     vocabulary doesn't sort in pipeline order.
  2. `crdt_state::write_item` takes typed `&Stage`, serialising via
     `stage_dir_name` at the CRDT boundary. `#[cfg(test)] write_item_str`
     parses legacy strings for test fixtures.
  3. `WorkItem::stage()` returns typed `crdt_state::Stage`; `stage_str()`
     is gone from the public API. Projection dispatches on the typed enum.
  4. `frozen` becomes an orthogonal CRDT register. `Stage::Frozen` and
     `PipelineEvent::Freeze`/`Unfreeze` are removed; `transition_to_frozen`/
     `unfrozen` set the flag directly without touching the stage register.
  5. Watcher sweep and `tool_update_story`'s `blocked` setter route through
     `apply_transition` so the typed transition table validates every
     stage change. `update_story` gains a `frozen` field for symmetry.
  6. One-shot startup migration rewrites pre-934 directory-style stage
     registers (and sets `frozen=true` on items previously at `7_frozen`).
     `Stage::from_dir` drops legacy aliases. The db boundary keeps a small
     normaliser so callers with legacy strings (MCP, tests) still work.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

server/src/crdt_state/write/migrations.rs

@@ -181,3 +181,88 @@ pub fn migrate_names_from_slugs() {
     }
     slog!("[crdt] Migrated names for {count} items from story ID slugs");
 }
+
+/// Map a pre-934 legacy directory-style stage string to its clean wire form.
+///
+/// Returns `None` if `s` is already in clean wire form (or is genuinely
+/// unknown), so the migration can quickly skip already-clean items.
+fn legacy_stage_to_clean(s: &str) -> Option<&'static str> {
+    match s {
+        "0_upcoming" => Some("upcoming"),
+        "1_backlog" => Some("backlog"),
+        "2_current" => Some("coding"),
+        "2_blocked" => Some("blocked"),
+        "3_qa" => Some("qa"),
+        "4_merge" => Some("merge"),
+        "4_merge_failure" => Some("merge_failure"),
+        "5_done" => Some("done"),
+        "6_archived" => Some("archived"),
+        // Story 934, stage 4: `Stage::Frozen` no longer exists.  Items that
+        // were previously frozen become orthogonal-flag-frozen: their stage
+        // register collapses to `backlog` (a safe "not progressing" default
+        // since the original resume_to payload was lost when the variant was
+        // dropped) and a separate write sets `frozen = true`.
+        "7_frozen" => Some("backlog"),
+        _ => None,
+    }
+}
+
+/// Rewrite every pipeline item whose `stage` register still carries a pre-934
+/// directory-style string (`"2_current"`, `"4_merge"`, etc.) to the clean wire
+/// vocabulary (`"coding"`, `"merge"`, etc.).
+///
+/// Items that were at `"7_frozen"` additionally get the new `frozen` flag set
+/// — the stage variant `Frozen` was dropped in story 934 stage 4 in favour of
+/// an orthogonal CRDT register.
+///
+/// One-time startup migration: items that have transitioned at least once
+/// since story 934 stage 1 (which made writes emit clean form) are no-ops.
+pub fn migrate_legacy_stage_strings() {
+    let Some(state_mutex) = get_crdt() else {
+        return;
+    };
+
+    // First pass: collect (index, clean_stage, set_frozen) for items that
+    // still carry legacy stage strings.
+    let migrations: Vec<(usize, &'static str, bool)> = {
+        let Ok(state) = state_mutex.lock() else {
+            return;
+        };
+        state
+            .index
+            .iter()
+            .filter_map(|(_story_id, &idx)| {
+                let item = &state.crdt.doc.items[idx];
+                let current = match item.stage.view() {
+                    JsonValue::String(s) => s,
+                    _ => return None,
+                };
+                let clean = legacy_stage_to_clean(&current)?;
+                let was_frozen = current == "7_frozen";
+                Some((idx, clean, was_frozen))
+            })
+            .collect()
+    };
+
+    if migrations.is_empty() {
+        return;
+    }
+
+    let Ok(mut state) = state_mutex.lock() else {
+        return;
+    };
+    let count = migrations.len();
+    let frozen_count = migrations.iter().filter(|(_, _, f)| *f).count();
+    for (idx, clean, was_frozen) in migrations {
+        apply_and_persist(&mut state, |s| {
+            s.crdt.doc.items[idx].stage.set(clean.to_string())
+        });
+        if was_frozen {
+            apply_and_persist(&mut state, |s| s.crdt.doc.items[idx].frozen.set(true));
+        }
+    }
+    slog!(
+        "[crdt] Migrated {count} legacy stage strings to clean wire form \
+         ({frozen_count} of which were '7_frozen' → backlog + frozen=true)"
+    );
+}