Norn/state/map.yaml

experiment:
  name: Norn
  status: active
  phase: in_repo_rust_solver_authority
  premise: >
    Test whether a Rust hybrid Sugiyama / Kamada-Kawai 2D and 3D layout solver
    with React/WASM and C# windows can make typed Epiphany machine maps
    inspectable without drowning humans or agents in transcript fog, static
    export artifacts, or engine furniture.

objective:
  primary: >
    Provide the Rust hybrid graph layout solver for Epiphany-style typed state:
    architecture graphs, dataflow graphs, and cross-links rendered through
    React/WASM and C# windows.
  current: >
    Publish Norn graph semantics through a runtime-independent Eve plugin
    sidecar while keeping the Rust solver authoritative and treating renderers
    as projections rather than semantic owners.

constraints:
  - Keep persistent state small enough to rehydrate quickly.
  - Prefer typed graph contracts over engine-specific public controls.
  - Do not let root C# project shape, MSAGL support code, or MCP exports define
    repo identity.
  - Do not add fallback layout truth behind the Rust solver for realtime viewer
    modes.
  - Treat benchmarks and rendered inspection as the proof layer for visual
    claims.
  - Keep C# bridge work peripheral unless it explicitly routes to the Rust
    solver and protects a named consumer contract.

invariants:
  - `state/map.yaml` is canonical slow memory, not a running diary.
  - `state/scratch.md` is disposable task memory.
  - `notes/fresh-workspace-handoff.md` is the short re-entry packet.
  - `crates/norn-rs` is the Rust layout solver source and crate authority.
  - `crates/norn-eve-plugin` owns Eve plugin ABI dispatch and stdio framing.
  - Provider state remains provider-owned; the plugin returns semantic and
    measurement results but cannot commit provider commands or receipts.
  - `web/norn-viewer` is the live React/WASM client package.
  - The .NET generator and MCP server are peripheral support surfaces for
    Obsidian exports, legacy inspection, package tooling, and benchmark
    fixtures.
  - The Rust solver WASM bundle is the layout authority for 2D and 3D hybrid
    layout modes; failures should be visible rather than silently replaced.
  - Public viewer API remains coarse: state, layout intent, motion/performance
    knobs, selection/focus, expanded node, and callbacks.
  - Visual or layout improvements require visible inspection, benchmark output,
    or both.

data_flow:
  observe:
    - typed Epiphany graph state from host applications
    - Rust solver source and exported WASM from `crates/norn-rs`
    - Obsidian vault notes only for legacy static graph generation
    - benchmark corpora and blind graph-truth probes
    - rendered viewer or SVG output as the user-visible truth layer
  process:
    - validate and normalize graph state at the viewer boundary
    - call the Rust solver through the WASM bridge for authoritative layout
    - treat browser motion as presentation around the solver anchor
    - render graph partitions, cross-links, labels, selection, and detail panes
    - measure visual usefulness through benchmark artifacts when tuning
    - dispatch typed Eve plugin requests and route graph measurement to the
      Rust solver without importing any provider or renderer implementation
  output:
    - React `NornViewer` package exports
    - embedded solver WASM bytes under `web/norn-viewer/src/lib`
    - demo build artifacts under `web/norn-viewer/dist`
    - static SVG/JSON generator output under requested output directories
    - benchmark baselines and review artifacts under `benchmarks/` or `out/`
    - Norn-owned plugin advertisements, ABI fixtures, and schemas
    - sequential NDJSON plugin responses over stdio

active_subgoals:
  - Keep the React/WASM viewer API stable and coarse.
  - Preserve Rust solver authority for hybrid Sugiyama / Kamada-Kawai 2D and 3D
    layout.
  - Use benchmark harnesses before claiming visual usefulness or realtime budget
    improvement.
  - Keep persistent project state distilled and current.
  - Add CultMesh transport as another carrier for the same typed request and
    response model when the daemon host contract is ready.

accepted_design:
  - The Rust crate under `crates/norn-rs` is the primary product surface and
    solver authority.
  - The React/WASM viewer backed by the Rust solver is the primary inspection
    client.
  - The root .NET generator and MCP server remain bridge/export/support
    surfaces.
  - Viewer motion is a presentation layer around the base layout anchor, not a
    second durable graph truth.
  - Benchmark probes should measure whether rendered graphs improve graph-truth
    recovery, not whether they look impressive.
  - The Eve sidecar is transport and ABI ownership around `norn-rs`; it is not
    a Unity, web, Sai, or provider-specific plugin host.

rejected_paths:
  - name: dual_client_surface
    reason: >
      Making the C# generator and React/WASM viewer equal consumer surfaces
      would split authority and force clients to understand implementation
      history.
  - name: shadow_solver_fallback
    reason: >
      Quietly replacing failed Rust solver output would create a second layout
      truth and hide the failure mode from consumers.
  - name: visual_vibes_as_evidence
    reason: >
      Attractive graph output is not proof that agents or humans can recover
      graph truth from the render.
  - name: csharp_repo_identity
    reason: >
      The root `.csproj` is peripheral bridge/export machinery. Treating it as
      the repo's identity hides the React/WASM frontend and Rust solver body.

current_status:
  summary: >
    Norn owns its first executable Eve graph plugin sidecar. The sidecar
    validates and measures graph documents through the Rust solver over a
    bounded NDJSON stdio protocol; React/WASM, C#, Unity, and other runtimes
    remain consumers that project the result.
  next_action: >
    For the next feature or fix, rehydrate from this map, identify the owning
    surface, then verify against the solver, WASM bridge, viewer, or visible
    render layer that actually carries the invariant.

verification:
  default_checks:
    - command: "npm run typecheck"
      cwd: "E:\\Projects\\Norn\\web\\norn-viewer"
      use_when: "React viewer TypeScript or API changes"
    - command: "npm run build"
      cwd: "E:\\Projects\\Norn\\web\\norn-viewer"
      use_when: "React viewer build, package, or demo changes"
    - command: "npm run tune:simulation"
      cwd: "E:\\Projects\\Norn\\web\\norn-viewer"
      use_when: "Realtime simulation budget or sampling changes"
    - command: "npm run profile:solver"
      cwd: "E:\\Projects\\Norn\\web\\norn-viewer"
      use_when: "Rust solver WASM or layout performance claims"
    - command: "cargo test"
      cwd: "E:\\Projects\\Norn"
      use_when: "Rust solver source or algorithm changes"
    - command: "cargo clippy --workspace --all-targets -- -D warnings"
      cwd: "E:\\Projects\\Norn"
      use_when: "Rust solver or Eve plugin sidecar changes"
    - command: "dotnet build E:\\Projects\\Norn\\Norn.csproj"
      cwd: "E:\\Projects\\Norn"
      use_when: "Peripheral C# bridge, export, or MCP changes"