For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (
- [ ]) syntax for tracking.
Goal: Make the MAD Designer workspace a working WPF report-layout studio (palette, minimap, zoomable canvas, inspector, undo) by extending mad serve with a report-layout model the client can read and mutate.
Architecture: Extend the Phase 4 serve protocol with a layout-model read plus granular mutations over the existing RptqDocumentSection/RptqDocumentElement objects (the same pattern as the 6b query-model). The WPF side mirrors the Mac’s MADMacDesignerViewController/MADMacDesignerCanvasView: a DesignerViewModel owns the snapshot and every mutation (with a client-side undo/redo stack), a DesignerCanvas draws bands/elements, and the three-pane DesignerView hosts palette/sidebar/inspector.
Tech Stack: Objective-C (engine, CLI/Source/MADCLIServe.m), C# / .NET 10 / WPF / MVVM (no framework), xunit (Mad.Designer.Windows.Tests).
Spec: docs/superpowers/specs/2026-11-19-designer-design.md (this plan argues from it; read both). Behavioural blueprint: Mac/Source/MADMacDesignerViewController.m, Mac/Source/MADMacDesignerCanvasView.m, Mac/Tests/MADMacSmokeTest.m step 5. Protocol record: docs/project/MAD_WINDOWS.md §6d/§6e.
windows-engine; commit with git commit -s (DCO); push to origin; PR #32 stays a draft; do not merge to master.NSUndoManager equivalent exists in WPF.[Image]); PDF/rendering deferred.CLI/Source/MADCLIServe.m (+ imports); rebuild mad.exe after editing it.The five input classes most likely to bite a real user, which the happy-path acceptance doesn’t exercise:
RptqDocumentSectionRows; addDocumentObject:withDropPoint: reads hasRows.firstObject. The engine must auto-create the first row (the Mac’s ensureSelectedSection). → pinned by Task 2’s AddElement_AutoCreatesFirstRow.height = interfaceHeight + 44 (setInterfaceHeight:); the protocol must read layoutHeight and write setInterfaceHeight: or the value drifts +44pt every round-trip. → pinned by Task 2’s SetSectionHeight_RoundTripsWithoutDrift.NextAvailableOrigin_DoesNotOverlapExisting.UndoRestoresCrossSectionMove.RemoveBoundElement_LeavesEmptyLayout.Files:
Windows/App/Mad.Designer.Windows/Models/LayoutModel.csWindows/App/Mad.Designer.Windows.Tests/LayoutModelTests.csInterfaces:
enum SectionType { Unknown=0, ReportHeader=1, ReportFooter=2, PageHeader=3, PageFooter=4, Body=5, GroupHeader=6, GroupFooter=7 } (matches MADocumentSectionType.h).enum ElementType { LabelDynamic=0, LabelStatic=1, Image=2, Chart=3, Formula=4, Aggregate=5, GroupKey=6, AggregateFunctionList=7, Whitespace=8, Barcode=9, LabelLink=10 } (matches MADDocumentObjectType.h).enum AggregateFunction { Unknown=0, Sum=2, Mean=3, First=5, Last=7, Count=11, Min=13, Max=17 }.enum AggregateScope { Unknown=0, Page=2, Report=3, Section=5 }.enum HorizontalAlignment { Left=0, Center=1, Right=2 }; enum VerticalAlignment { Top=0, Center=1, Bottom=2 }.enum PaperSize { Letter=2, Legal=7, A4=19 }.record LayoutSection(long Id, SectionType Type, string Title, double Height, bool Visible, bool PageBreak, string? GroupField).record LayoutElement(long Id, ElementType Type, long Section, double X, double Y, double W, double H, string Text, long Field, string Table, string Column, AggregateFunction Function, AggregateScope Scope, int Group, string FontName, double FontSize, bool Bold, bool Italic, bool Underline, bool Strikethrough, HorizontalAlignment HAlign, VerticalAlignment VAlign, double BorderTop, double BorderBottom, double BorderLeft, double BorderRight, double Padding, double Margin).record LayoutField(long Id, string Name, string Table, string Display).record LayoutModel(int PaperSize, IReadOnlyList<LayoutSection> Sections, IReadOnlyList<LayoutElement> Elements, IReadOnlyList<LayoutField> Fields) with static LayoutModel Parse(JsonElement root).LayoutElement.IsLabel (Type is LabelStatic and bottom border ≤ 0), IsLineRule (LabelStatic and BorderBottom > 0), IsDataField (LabelDynamic), IsAggregate (Aggregate), IsImage (Image).Step 1: Write the failing test — LayoutModelTests.Parse_ReadsAllFields parses an inline JSON fixture (a layout-model result with one section, one label element, one field) and asserts every property (PaperSize 19, section Type ReportHeader/Id/Title/Height/Visible/PageBreak/GroupField, element Id/Type/Section/X/Y/W/H/Text/Field/Table/Column/Function/Scope/Group/FontName/FontSize/4 bools/HAlign/VAlign/4 borders/Padding/Margin, field Id/Name/Table/Display). A second test Parse_MissingOptionalFields_UsesDefaults parses a minimal { "paperSize": 2, "sections": [], "elements": [], "fields": [] } and asserts empty lists and default numeric/bool values without throwing.
Step 2: Run test to verify it fails — dotnet test ./Windows/App/Mad.Designer.Windows.Tests → FAIL (type LayoutModel not found).
Step 3: Implement the records/enums and Parse in Models/LayoutModel.cs. Parse reads each property with TryGetProperty + a default (numeric GetInt32/GetDouble, bool GetBoolean), and Elements/Sections/Fields via EnumerateArray — mirroring Models/QueryModel.cs. String properties default to ""; GroupField/Table/Column to null only when the JSON value is absent or JsonValueKind.Null.
Step 4: Run test to verify it passes — dotnet test ./Windows/App/Mad.Designer.Windows.Tests → PASS.
git add Windows/App/Mad.Designer.Windows/Models/LayoutModel.cs Windows/App/Mad.Designer.Windows.Tests/LayoutModelTests.cs && git commit -s -m "feat(designer): parse the report-layout model snapshot".Files:
CLI/Source/MADCLIServe.m (add imports, method-name constants, 11 handlers, dispatch branches).Windows/App/Mad.Designer.Windows/Engine/EngineService.cs (11 async methods + payload records).Windows/App/Mad.Designer.Windows.Tests/LayoutModelTests.cs (add round-trip facts).Interfaces:
LayoutModel.Parse (Task 1).Task<LayoutModel> LayoutModelAsync(int handle).Task<LayoutModel> AddElementAsync(int handle, string kind, long section, double x, double y) (kind ∈ "label"|"data-field"|"aggregate"|"image"|"line").Task<LayoutModel> RemoveElementsAsync(int handle, IReadOnlyList<long> elements).Task<LayoutModel> DuplicateElementsAsync(int handle, IReadOnlyList<long> elements).Task<LayoutModel> MoveElementsAsync(int handle, IReadOnlyList<long> elements, long section).Task<LayoutModel> SetElementGeometryAsync(int handle, IReadOnlyList<ElementGeometry> elements) where record ElementGeometry(long Id, double X, double Y, double W, double H).Task<LayoutModel> SetElementContentAsync(int handle, long element, ElementContent content) where record ElementContent(string? Text, long? Field, int? Function, int? Scope, int? Group).Task<LayoutModel> SetElementTypographyAsync(int handle, IReadOnlyList<long> elements, ElementTypography style) where record ElementTypography(string? FontName, double? FontSize, bool? Bold, bool? Italic, bool? Underline, bool? Strikethrough, int? HAlign, int? VAlign).Task<LayoutModel> SetElementBoxModelAsync(int handle, IReadOnlyList<long> elements, ElementBoxModel box) where record ElementBoxModel(double? BorderTop, double? BorderBottom, double? BorderLeft, double? BorderRight, double? Padding, double? Margin).Task<LayoutModel> SetSectionAsync(int handle, long section, double? height, bool? visible, bool? pageBreak).Task<LayoutModel> SetPaperSizeAsync(int handle, int paperSize).LayoutModelTests.cs (same [Collection("Engine")] + CopyChinookToTemp() pattern as QueryModelTests.cs), a single LayoutRoundTrip_AddMoveResizeSetSection_And_RemoveBoundElement fact:
.mad; LayoutModelAsync → assert Sections has the canonical order (Report Header first, then Page Header, then Detail; PaperSize == 2).AddElementAsync("label", detailSectionId, 10, 20) → element Type LabelStatic, X 10, Y 20, Text “Static Label”.AddElementAsync("data-field", detailSectionId, 0, 0) and AddElementAsync("aggregate", detailSectionId, 0, 0) → all three element Ids distinct (assert three elements).SetElementGeometryAsync([{label, x: 111, y: 22, w: 200, h: 30}]) → element reads X 111 / Y 22 / W 200 / H 30.MoveElementsAsync([labelId], pageHeaderSectionId) → label’s Section is the page-header id and X/Y preserved.SetSectionAsync(pageHeaderSectionId, height: 120, visible: true, pageBreak: false) → that section’s Height == 120 and PageBreak false.RemoveElementsAsync([labelId, dataFieldId, aggregateId]) → Elements empty.AddElement_AutoCreatesFirstRow: on a freshly created document, AddElementAsync("label", detailSectionId, 5, 5) succeeds (no engine error) and returns one element.SetSectionHeight_RoundTripsWithoutDrift: SetSectionAsync(detailSectionId, height: 137) then LayoutModelAsync → that section’s Height == 137 (not 181).Step 2: Run tests to verify they fail — dotnet test ./Windows/App/Mad.Designer.Windows.Tests → FAIL (unknown method 'layout-model' / engine error).
MADCLIServe.m. Add imports (RptqDocumentSection+Extras.h, RptqDocumentSectionRows.h, RptqDocumentElement+Extras.h, the label/data-field/aggregate/image headers, MADDocumentObjectType.h, MADocumentSectionType.h, MADAggregateFunctionType.h, MADAggregateFunctionGroupByType.h, MADAlignment.h, MTPaper.h). Add:
MADCLIServeLayoutModelDict(document) — reads the live RptqDocument via [RptqDocument newDocumentReadFromManagedObjectContext: document.storeContext]; serializes paperSize, sections[] (order of MADMacDocument -orderedSections, reading layoutHeight for height with fallback MAX(36, height-44), visibility, producesFormFeed, group field name via inGroup), elements[] (from each section’s rows’ hasObjects, reading rect.origin.x/y/rect.size.width/height with dropPoint fallback, per-type content, textStyle/alignment/border.width/padding/margin/numericFormat), and fields[] (main query’s hasQueryTables→hasQueryFields → { id, name, table=alias, display="alias.name" }).MADCLIServeAddElement — look up section by id (documentSectionForObjectID:); if hasRows.count == 0, insert a RptqDocumentSectionRows and addHasRowsFixed:; create the element by kind (label → RptqDocumentElementLabel type LabelStatic text “Static Label” size 124×22; data-field → RptqDocumentElementLabelDataField type LabelDynamic bound to first query field size 140×22; aggregate → RptqDocumentElementAggregate type Aggregate MTAggregateFunctionTypeSum scope derived from section type, size 144×22; image → RptqDocumentElementImage type Image size 96×64; line → RptqDocumentElementLabel type LabelStatic empty text + bottom border 1.5, size 320×8); then addDocumentObject:withDropPoint:managedObjectContext: + set inSectionRow + setElement:originInSectionContent: (all as MADMacDesignerViewController -attachElement:…).MADCLIServeRemoveElements, MADCLIServeMoveElements (port moveElement:toSection:atOrigin:), MADCLIServeSetElementGeometry (setElement:originInSectionContent: + setSizeWidth:height:), MADCLIServeSetElementContent, MADCLIServeSetElementTypography, MADCLIServeSetElementBoxModel, MADCLIServeSetSection (setInterfaceHeight:, visibility, setProducesFormFeed:), MADCLIServeSetPaperSize, MADCLIServeDuplicateElements (clone by kind, copy content/style/size, offset +16/+12).MADCLIServeDispatch.MADCLIServeWriteResult(requestID, MADCLIServeLayoutModelDict(document)); a bad param answers MADCLIServeWriteError(requestID, MADCLIExitUsage, …).Step 4: Implement the EngineService methods in EngineService.cs, following the QueryModelAsync/AddTableAsync pattern (build Dictionary<string, object?>, CallAsync, return LayoutModel.Parse). Serialize IReadOnlyList<long> as long[], IReadOnlyList<ElementGeometry> as Dictionary<string,object?>[] of {id,x,y,w,h}, and skip null members of the payload records.
Step 5: Rebuild the engine and run tests — rebuild mad.exe: pwsh -File ./Windows/Engine/build.ps1 -SkipToolchain (elevated, PowerShell 7, from C:\dev\MAD); then dotnet test ./Windows/App/Mad.Designer.Windows.Tests → PASS (all LayoutModelTests + existing suites).
git add CLI/Source/MADCLIServe.m Windows/App/Mad.Designer.Windows/Engine/EngineService.cs Windows/App/Mad.Designer.Windows.Tests/LayoutModelTests.cs && git commit -s -m "feat(designer): expose the report-layout model over serve".Files:
Windows/App/Mad.Designer.Windows/ViewModels/DesignerViewModel.csWindows/App/Mad.Designer.Windows.Tests/DesignerViewModelTests.csInterfaces:
EngineService layout methods (Task 2), LayoutModel/LayoutElement/LayoutSection (Task 1).DesignerViewModel(EngineService engine).bool HasDocument, LayoutModel Model, IReadOnlyList<LayoutSection> Sections, IReadOnlyList<LayoutElement> Elements, IReadOnlyList<LayoutField> Fields.long SelectedSectionId, IReadOnlyList<long> SelectedElementIds, LayoutElement? PrimaryElement.double Zoom { get; set; } (0.5–2.5), bool ShowGrid, bool SnapToGrid, bool ShowRulers.Task LoadAsync(int handle) and Task ReloadAsync().void SelectSection(long id), void SelectElement(long id, bool extend), void ClearElementSelection().Point NextAvailableOrigin(long sectionId, double w, double h) — the Mac’s nextAvailableOriginInSection:forElementSize: ported to C# (bottom row, rightmost, grid snap, non-overlap).Task<LayoutModel> AddElementAsync(string kind, long section, double x, double y), RemoveElementsAsync, DuplicateElementsAsync, MoveElementsAsync, SetElementGeometryAsync, SetElementContentAsync, SetElementTypographyAsync, SetElementBoxModelAsync, SetSectionAsync, SetPaperSizeAsync — thin wrappers over EngineService that re-apply the snapshot and update selection.Step 1: Write the failing test — DesignerViewModelTests.NextAvailableOrigin_DoesNotOverlapExisting: construct a DesignerViewModel and inject a stubbed LayoutModel (no engine call — the method is pure over Elements/Sections); place a 120×22 element at (16,10); assert NextAvailableOrigin(sectionId, 120, 22) returns a point whose rect does not intersect it, and that for an empty section it returns (16,10) (snapped to the default 8pt grid when SnapToGrid is true).
Step 2: Run test to verify it fails — dotnet test … → FAIL (type not found).
Step 3: Implement DesignerViewModel with the state/selection/commands above. Keep the engine-call wrappers identical in shape to QueryViewModel.MutateAsync (set IsBusy, apply the returned LayoutModel, OnPropertyChanged for the dependent properties). NextAvailableOrigin port the Mac algorithm literally.
Step 4: Run test to verify it passes — dotnet test … → PASS.
git add Windows/App/Mad.Designer.Windows/ViewModels/DesignerViewModel.cs Windows/App/Mad.Designer.Windows.Tests/DesignerViewModelTests.cs && git commit -s -m "feat(designer): DesignerViewModel with snapshot, selection, placement".Files:
Windows/App/Mad.Designer.Windows/Views/DesignerCanvas.csWindows/App/Mad.Designer.Windows.Tests/DesignerCanvasTests.csInterfaces:
DesignerViewModel (Task 3), LayoutModel (Task 1).Produces (Tasks 5–10): public sealed class DesignerCanvas : Canvas with void Attach(DesignerViewModel vm) and double Zoom applied as a ScaleTransform/recompute; it draws one Border per section (band: header + content + resize bar) and one Border/TextBlock per element, tags each with its id, and re-renders on DesignerViewModel.Model / selection changes. Layout constants mirror the Mac: paper width 612pt (Letter) scaled to device pixels, outer margin 28, ruler 20, section header 24, resize bar 7, gap 12, grid 8.
Step 1: Write the failing test — DesignerCanvasTests.CanvasRendersBandsAndElements: STA thread (copy QueryCanvasTests structure) creates a DesignerViewModel over a real engine, LoadAsync, AddElementAsync("label", …), attaches a DesignerCanvas, calls Measure/Arrange/UpdateLayout, and asserts: the number of section Borders equals vm.Sections.Count, the number of element Borders equals vm.Elements.Count, and no exception is thrown.
Step 2: Run test to verify it fails — dotnet test … → FAIL (type not found).
Step 3: Implement DesignerCanvas — port the Mac’s drawSectionBand/drawElement/recalculateCanvasSize into WPF FrameworkElements, computing band/content rects from the model (paper width, section order/heights, element rects). Rendering-only in this task; hit-testing and drag come in Task 10.
Step 4: Run test to verify it passes — dotnet test … → PASS.
git add Windows/App/Mad.Designer.Windows/Views/DesignerCanvas.cs Windows/App/Mad.Designer.Windows.Tests/DesignerCanvasTests.cs && git commit -s -m "feat(designer): render report bands and elements on a WPF canvas".Files:
Windows/App/Mad.Designer.Windows/Views/DesignerView.xaml (replace placeholder) + .xaml.cs.Windows/App/Mad.Designer.Windows/ViewModels/DocumentViewModel.cs (add Designer child, load on open/reconnect).docs/project/MAD_WINDOWS.md (§6f layout protocol), Windows/README.md (Designer section).Interfaces:
DesignerViewModel (Task 3), DesignerCanvas (Task 4).Produces: DocumentViewModel.Designer { get; } (a DesignerViewModel), loaded in LoadAsync (after Query.LoadAsync) and re-loaded in ApplyConnectionAsync.
Step 1: Wire DesignerViewModel into DocumentViewModel — construct it in the ctor, call await Designer.LoadAsync(_handle) in LoadAsync and ApplyConnectionAsync, and expose public DesignerViewModel Designer { get; }.
Step 2: Build DesignerView.xaml — a DockPanel: top palette bar (38pt; placeholder buttons in this task), then a Grid with three ColumnDefinitions (220 / * / 260) and two GridSplitters; centre hosts a ScrollViewer wrapping the DesignerCanvas (attached to the VM in code-behind); left/right are placeholder headers (“Minimap”, “Report Bands”, “Query Fields”, “Inspector”).
Step 3: Update the docs — docs/project/MAD_WINDOWS.md gains §6f documenting the 11 methods and the snapshot shape; Windows/README.md’s WPF-shell paragraph mentions the Designer canvas.
Step 4: Build and verify — dotnet build ./Windows/App/Mad.Designer.Windows/Mad.Designer.Windows.csproj → succeeds; dotnet test ./Windows/App/Mad.Designer.Windows.Tests → PASS.
git add -A && git commit -s -m "feat(designer): three-pane Designer shell and layout-protocol docs".Files:
Views/DesignerView.xaml (+ code-behind), ViewModels/DesignerViewModel.cs.Interfaces:
DesignerViewModel.AddElementAsync + NextAvailableOrigin (Task 3).Produces: six palette buttons (Label, Data Field, Aggregate, Barcode [disabled], Image, Line) that call AddElementAsync(kind, SelectedSectionId, NextAvailableOrigin(…)).
Step 1: Implement the palette commands — DesignerViewModel.AddLabelCommand, AddDataFieldCommand, AddAggregateCommand, AddImageCommand, AddLineRuleCommand (AsyncRelayCommand, disabled when !HasDocument), each computing the default size (124/140/144/96/320 × 22/22/22/64/8) and calling NextAvailableOrigin then AddElementAsync. Barcode button is present but IsEnabled=false.
Step 2: Bind the top bar in DesignerView.xaml.
Step 3: Verify — dotnet build … succeeds; dotnet test … → PASS.
git add -A && git commit -s -m "feat(designer): palette click-to-add with non-overlapping placement".Files:
Views/DesignerMinimap.cs.Views/DesignerView.xaml, ViewModels/DesignerViewModel.cs.Interfaces:
DesignerViewModel sections/elements/fields (Task 3), DesignerCanvas (Task 4).Produces: DesignerMinimap : Canvas with Attach(DesignerViewModel) — draws miniature bands/elements plus a viewport box, and mouse-down/drag selects a section (calls vm.SelectSection). Sidebar lists sections (double-click toggles visibility) and fields (double-click inserts a bound data field via AddElementAsync("data-field", selected, nextOrigin)).
Step 1: Add Fields/sections display helpers + field-insert command to DesignerViewModel.
Step 2: Implement DesignerMinimap (port MADMacDesignerMinimapView).
Step 3: Build the sidebar in XAML (minimap + ListBox of sections + ListBox of fields, wired to the VM; double-click handlers in code-behind).
Step 4: Verify — build + test PASS.
git add -A && git commit -s -m "feat(designer): minimap, sections outline, query-fields browser".Files:
Views/DesignerView.xaml, ViewModels/DesignerViewModel.cs.Interfaces:
DesignerViewModel selection + setters (Task 3).Produces: inspector with a document/section card (paper size, section height/visible/page-break) and an element card (identity/badge + band assignment, content & binding, typography, geometry & box model) bound to the selected element/section; edits call the Set…Async methods.
Step 1: Add bound edit properties/commands to DesignerViewModel (e.g. SelectedPaperSize, SelectedSectionHeight, SelectedSectionVisible, SelectedSectionPageBreak, and per-element geometry/content/typography/box-model setters that call the corresponding Set…Async).
Step 2: Build the inspector XAML (cards + fields, contextual visibility by element type; omit the colour wells — deferred).
Step 3: Verify — build + test PASS.
git add -A && git commit -s -m "feat(designer): selected element/section inspector".Files:
ViewModels/UndoRedoStack.cs (or nested in DesignerViewModel.cs).Windows/App/Mad.Designer.Windows.Tests/UndoRedoTests.cs.Interfaces:
DesignerViewModel mutation wrappers (Task 3).Produces: UndoRedoStack with record UndoableEdit(string Name, Func<Task<LayoutModel>> Undo, Func<Task<LayoutModel>> Redo); bool CanUndo/CanRedo, void Push(edit), Task<LayoutModel> Undo(), Task<LayoutModel> Redo(). DesignerViewModel gains CanUndo/CanRedo/UndoCommand/RedoCommand and routes every mutation through a MutateAsync(name, doFn, undoFn) helper that captures the pre-state and computes the inverse.
Step 1: Write the failing test — UndoRedoTests.UndoRedo_RestoresGeometryAndCrossSectionMove over a real engine: add a label; SetElementGeometryAsync to (111,22); Undo → geometry back to the inserted origin; Redo → (111,22); then MoveElementsAsync to Page Header; Undo → section is Detail again; Redo → Page Header.
Step 2: Run test to verify it fails — dotnet test … → FAIL (no undo API).
Step 3: Implement UndoRedoStack + wire into DesignerViewModel — every mutation records its inverse (geometry set-back, add→remove, remove→re-add with saved element, move→move-back, content/typography/box/section/paper restore-previous). Coalesce consecutive set-element-geometry edits from a single drag.
Step 4: Run test to verify it passes — dotnet test … → PASS.
git add -A && git commit -s -m "feat(designer): client-side undo/redo over protocol mutations".Files:
Views/DesignerCanvas.cs, ViewModels/DesignerViewModel.cs.Interfaces:
DesignerViewModel (Tasks 3, 6–9).Produces: full interactivity — drag-to-move (with cross-section hover), 8-handle resize, rubber-band marquee, smart alignment guides, grid snap, zoom (toolbar slider), rulers toggle, inline label editing (double-click/Enter), Delete/Duplicate (context menu + keyboard), all committing geometry through SetElementGeometryAsync/MoveElementsAsync so undo/redo captures them.
Step 1: Implement drag/move/resize/marquee in DesignerCanvas (port the Mac’s mouseDown/Dragged/Up state machine; hit-test handles and sections).
Step 2: Implement alignment guides + grid snap + zoom + rulers in the canvas and the toolbar toggles.
Step 3: Implement inline label edit + Delete/Duplicate (context menu and Delete/Ctrl+D keys).
Step 4: Verify — build + test PASS; manually launch under RDP (dotnet run --project ./Windows/App/Mad.Designer.Windows) to eyeball the interactions.
git add -A && git commit -s -m "feat(designer): canvas move/resize/marquee/guides/snap/zoom/inline-edit".Files:
Windows/App/Mad.Designer.Windows.Tests/DesignerAcceptanceTests.cs.docs/project/MAD_WINDOWS.md, Windows/README.md (final polish).C:\dev\mad-win-reports\phase6c-summary.md.Interfaces:
Consumes: everything above.
Step 1: Write DesignerAcceptanceTests mirroring MADMacSmokeTest step 5: three non-overlapping elements; X/Y edit persists and undo/redo restores geometry; UndoRestoresCrossSectionMove (Detail → Page Header → undo); delete + duplicate; section height round-trips.
Step 2: Run the full suite — dotnet test ./Windows/App/Mad.Designer.Windows.Tests and the engine suites (pwsh -File ./Windows/Engine/build.ps1 -SkipToolchain) → all green.
Step 3: Push — git push origin windows-engine; confirm DCO + Linux verification green.
Step 4: Write phase6c-summary.md — record what shipped, the test counts, and the explicit deferred items (“colours deferred”, “image = placeholder”, “barcode disabled”, “PDF deferred”), so the merge-gate review can see exactly what the Windows Designer does not yet edit.
Step 5: Commit/push the docs + summary pointer — git add -A && git commit -s -m "docs(designer): acceptance tests and merge-gate notes" && git push origin windows-engine.