Skip to content

anatoliykant/iphone-duo

v1.4.6MIT

Adapt, audit and design-review iOS apps for iPhone Duo — Apple's foldable iPhone (iOS 27.1): size classes, vertical bars, reserved regions, arrangement views, hinge, scenes, dual cameras; a shared read-only readiness audit; a HIG design review of Figma/Sketch mockups; foldsim, a simulator CLI that puts an iPhone Duo, iPhone or iPad into every pose and says what to check there.

Changelog

All notable changes to this plugin are documented here. The format follows Keep a Changelog.

Each release bumps both plugin.json (Codex / Agent Plugins) and .claude-plugin/plugin.json (Claude Code), plus the version literals in both skills, and uses a matching git tag. See README.md for the update commands for each host.

[1.4.6] — 2026-11-08

Takes in the test app's own bisect of the same switch, which the probe then confirmed.

Fixed

  • Where an .identity switch animates at all (iphone-duo, reserved regions, anti-patterns, sources). 1.4.5 said the test app's reader on the ArrangementView worked because the arrangement stood between it and the switch. There is more to it. A .transition(.identity) switch tied with matchedGeometryEffect animates only inside an ArrangementView pane, where it crossfades while the shared elements move. Outside an arrangement it jumps even with no geometry reader, under a UIKit host or a bare UIHostingController. Inside the pane, an onGeometryChange on the switch or between it and the arrangement turns the animation off, while a modifier that only holds @State does not. The default .opacity transition animates everywhere, so it is the fallback when a reader has to sit next to the switch.

[1.4.5] — 2026-11-08

Finds what 1.4.4 left open, by bisecting a build of the test app itself on a Duo simulator (runtime 24B91014, Xcode 27.2 RC) and then reproducing it in the probe with no fold involved.

Fixed

  • What made the test app's fold switch jump (iphone-duo, reserved regions, anti-patterns, sources; foldsim pose checks). The layout switches two if/else branches with .transition(.identity) and ties the elements they share with matchedGeometryEffect. An onGeometryChange on that view, or on any view above it up to the nearest ArrangementView, makes the switch jump, and withAnimation's completion fires within 25 ms. One whose action never runs does it too, and a VStack or .padding in between does not help. A GeometryReader in .background, an ArrangementView in between, or the default transition keeps the animation. The test app's reader on the ArrangementView worked because the arrangement stood between it and the switch; without the arrangement the same reader made it jump.

Changed

  • The source of the field findings is called a test app (all references, CHANGELOG, README). Links to its private repository, pull requests and tickets are gone, and the GitHub release notes of 1.3.3–1.4.4 were rewritten the same way.

[1.4.4] — 2026-11-07

Corrects 1.4.3 with recordings of a test app's own screen, shared the same day.

Fixed

  • What made the test app's switch jump (iphone-duo, reserved regions, sources; foldsim pose checks). 1.4.3 blamed .transition(.identity) on the layout's two branches. The app's recordings rule that out (Duo simulator, runtime 24B91014, 2026-11-05). With the fold read outside the ArrangementView, the same layout with .transition(.identity) and matchedGeometryEffect animated: a run of 36 frames over 0.58 s. With the fold read inside, every variant jumped, including withAnimation, .animation(_:value:), the same call after DispatchQueue.main.async, and an .opacity on a view whose branch did not change. The 1.4.3 claim came from a simplified copy of the screen that jumped even without an arrangement. A minimal probe still keeps the animations it starts inside a pane, so what triggers the loss in that app is not known. The advice to read the fold on the ArrangementView stands.
  • Judge a recording by the move out of a pose (foldsim pose checks; the test app's method). Going into a pose, the simulator redraws the folded half as the hinge moves, so every variant shows a run of frames.

[1.4.3] — 2026-11-07

Takes in one finding from a test app's fourth set of Duo fixes: read the fold outside ArrangementView, because a withAnimation started inside it ends at once. It was checked with a probe app on a Duo simulator (runtime 24B91014, Xcode 27.2 RC), under a SwiftUI and a UIKit host, with the overlay, split and default styles and a copy of one of the app's layouts. The advice holds, for a different reason, and the early end did not repeat.

Added

  • Read the fold on the ArrangementView, not inside its panes (iphone-duo, reserved regions and anti-patterns; measured). A pane that the arrangement keeps beside the fold gets no division region, even with .includeInactive, so a reader inside it never sees the pose change. Read the region on the ArrangementView or above it and pass the fold into the content as a value, as the test app does; withAnimation there animated the change with every style.
  • What made the test app's switch jump (iphone-duo; measured; wrong, corrected in 1.4.4). Where the pane stays across the fold, an animation started inside it ran its full 0.5 s, from onGeometryChange, after DispatchQueue.main.async or as .animation(value:). The jump came from two if/else branches with .transition(.identity) tied with matchedGeometryEffect: they switched in one frame with or without an arrangement, even from a timer, and withAnimation's completion fired within 10 ms. With the default transition the switch animated.
  • Sizes jitter while a layout switches (iphone-duo; measured): a view whose layout switched with the fold read its height as 786 and 786.00000000000011 pt on alternate passes, with or without an arrangement, and each switch brought a second geometry callback. The ArrangementView itself stayed at 786. A "same size" test needs a tolerance.
  • Count the frames of a recording (foldsim pose checks): ffprobe lists when frames came, and a run over about half a second is an animation; a completion within a few milliseconds is not proof of one.

[1.4.2] — 2026-10-31

Takes in a test app's third set of Duo findings. Each was checked against the 27.2 RC SDK or with a probe app on a Duo simulator (runtime 24B91014); what the simulator cannot show is marked as the app's. Measuring the sheets went past the report: in the book pose a sheet reaches 12 pt into the fold band, and its safe area does not say so. Left out as the app's own: the column offsets of its layouts and the ±8 pt band its tests keep empty; flagging every flat layout that ignores the fold became a softer rule, since Apple lets flat layouts sit off-centre.

Changed

  • Animate on the fold, not on the layout kind (iphone-duo, reserved regions). 1.4.1 suggested .animation(.smooth, value: kind), but a resize in Split View can switch the kind as well, and an animated switch then trails the divider (the test app). Key the animation to the region's isActive, as the probe did; the app animates only when isActive flipped while the window kept its size.

Added

  • Sheet sizes in the book pose (iphone-duo, design review, foldsim pose checks; measured). Flat, a sheet is 653 × 661 pt. Folded, it takes one pane at 459.3 pt — the leading one by default, the trailing one with .trailing — and stops 8 pt short of the crease, so 12 pt of it lie inside the 40 pt band. Neither its safe area nor its layout margins cover that strip; the division region read inside the sheet does. Content clear of the band has about 447 pt. A trailing sheet whose preferredContentSize is no wider than the room beside the band — 447.5 pt, the test app's approach — stayed at x 495.5–943 in both poses; a wider one was squeezed into the pane and back into the band. Design rule D18 now flags sheet content of fixed width that fits only flat.
  • Sizes a view keeps from its first layout (iphone-duo layout, testing, foldsim pose checks; measured). A grid that computes its day width once keeps the flat width when the fold narrows its sheet, and its last column runs past the edge — the test app's JTAppleCalendar lost its last column and the selected day's frame that way. In a probe, the sheet controller's viewDidLayoutSubviews still saw the nested grid's old width, as Apple's documentation warns, so a width set there stayed wrong; set from the grid's own layoutSubviews and applied on the next run-loop turn, it followed both ways. Compare the width again after each reload, and test two changes in a row.
  • One query for both poses (iphone-duo; measured). A .includeInactive query returns the same band flat and folded, and only isActive changes, so a second, active-only query adds nothing; pick a region by isActive. The crease is frame.inset(by: margins), a zero-width rect at x 475.5.
  • Render tests on the open Duo (iphone-duo testing, foldsim pose checks). Open is two poses with one window, so a trait that checks "unfolded" lets flat and book through: branch the expectations on isActive or pin the pose with foldsim pose.
  • Doc indexes without the Duo APIs (iphone-duo, Verify symbols). cupertino 1.4.2, whose databases date from 2026-07-23, has no ReservedRegion, ArrangementView or UIHingeInteraction; grep the SDK instead.
  • Recording the fold (foldsim pose checks): simctl io recordVideo --display=3 around foldsim pose book, tried on the simulator.
  • foldsim screenshot prints the state after the files (--json: state) — hinge angle, active display, orientation — so a picture of the book pose cannot pass for a flat one. The test app had two identical screenshots and could not tell whether the pose had changed.
  • Design review: D25 asks for one rule for flat two-column splits across an app's screens. Flat may sit off-centre, as Apple's split views do at about 35/65; the test app's screens meet the fold line.

[1.4.1] — 2026-10-31

Takes in a test app's second set of Duo fixes. Each finding was checked with a probe app on a Duo simulator (runtime 24B91014) where the simulator can show it; the rest are marked as the app's. Two did not repeat and are written down as such: deep links timing out on the closed Duo, and a root .transaction that fails to stop a descendant's animation. Left out as not specific to the Duo: a custom bar glyph versus the nearest SF Symbol, the dismissal of a custom sheet, and aligning two UIKit tables side by side.

Fixed

  • The fold's keep-clear zone is the division region's frame: 40 pt on the simulator, not 80. 1.3.3 read the 20 pt margins as extra space around frame and doubled the zone to 80 pt (x or y 435–515). Apple's ReservedRegion pages and the 27.2 RC SDK header say the frame already includes the margins, and the simulator agrees: a split ArrangementView leaves exactly the 40 pt band between its panes in the book and table poses, on both Duo runtimes. Found while adapting a test app, whose layouts had padded the frame a second time and kept columns 40 pt from the fold instead of 20. The design-review rules and the source list no longer repeat the 80 pt figure.
  • foldsim: opening a Duo right after it boots no longer ends in exit 4. devicectl can miss that first switch and keep marking the cover display active for good, while the inner display shows the interface; pose open-landscape then reported "the inner display did not become active at 180°" although the Duo had opened (a test app). When exactly one display's backlight is on, foldsim now takes that one as active, and selftest checks the four flag pairs measured on the simulator. Also measured: a Duo shut down open came back closed after each of five reboots, so read state after booting.

Added

  • bounds.origin in a custom Layout (iphone-duo): from Apple's ReservedRegion page, compute against (0, 0) and add bounds.origin only when placing each view.
  • A fold reaches SwiftUI without an animation (iphone-duo, reserved regions; measured). Going flat ↔ book, the views that depend on the division region got a transaction with no animation, so a SwiftUI layout keyed to the fold jumps, while a UIKit view reading the regions in layoutSubviews was laid out inside a 0.5 s animation. .animation(.smooth, value: kind) on the container animates it, as does a test app's switch of a @State layout kind with withAnimation(.smooth) plus matchedGeometryEffect; no animation under Reduce Motion. Tell the table pose from the fold's frame, not by comparing pane edges, which read a zero-height window as a table.
  • Columns that meet closer than the band when flat (iphone-duo): a test app's mockups put them 18 and 9 pt from the centre line. The query without .includeInactive is empty flat, so take the line from the inactive region and switch to the active frame's edges when the device folds.
  • Testing (iphone-duo): snapshots of a layout that animates its switch — wait until two snapshots about 50 ms apart match; the Swift Testing trait that gates fold-dependent suites; simctl openurl works on the closed and the open Duo (measured) and asks "Open in …?" once per fresh simulator; a three-digit Live Activity counter that needed 13 pt, and the Dynamic Island missing from simctl screenshots (the test app's).
  • Design review: D14 gains a test app's media + text screen in the book pose — the whole image in the leading column, the text in the trailing one, rather than an empty leading half.

[1.4.0] — 2026-10-30

A third skill, foldsim: the plugin now puts a simulator into every pose itself instead of sending you to Device Hub's buttons, and says what to check there. Its code is written for this plugin in Swift, from Apple's open-source headers and the mechanisms described by two MIT projects (see NOTICE.md); no code is taken from them. Every command was checked against a probe app on throwaway simulators: Xcode 27.2 RC, Duo runtimes 24B91014 (27.2 RC) and 24A94425 (27.1), iPhone 18 Pro Max and iPad Pro 13-inch (M5) on 24B114.

The release also takes in what fixing six Duo QA bugs in a test app taught. Each finding was measured on a Duo simulator first (runtime 24B91014); the ones that could not be measured are marked as the app's.

Added

  • foldsim skill with a bundled CLI. A shell launcher compiles a macOS host and a helper that runs inside the simulator with your Xcode on first use (seconds; cached in ~/Library/Caches/foldsim).
    • iPhone Duo: hinge <degrees|closed|half|open> at Device Hub's pace, never an instant jump; pose closed-portrait | closed-landscape | tent | book | open-landscape | open-portrait | table, each reached the way a hand would and checked; rotate of whichever display is active.
    • iPhone and iPad: rotate through devicectl device orientation set.
    • Any display, the Duo's inner one included: tap, press, swipe in the app's interface points, and screenshot of the active display, the cover, the inner one or both.
    • tour: every pose of a Duo, or orientation of an iPhone or iPad, with a screenshot of every display, tour.json and tour.md.
    • state, devices, doctor (are the private interfaces still there), selftest (the geometry, on measured samples, without a simulator).
    • Exit code 3 when the app or the system refuses an orientation, so the orientation-mask check is a script. Exit 2 instead of a guess when several simulators are booted; foldsim never boots, shuts down or erases one.
    • references/pose-checks.md: both displays per pose, the hinge gate, the orientation mask, render-test windows, known simulator behaviour.
  • What the simulator does, measured for foldsim (and now in the skills):
    • which display is active depends on how the hinge got there: one continuous move switches displays between about 75° and 90°, opening or folding, at any pace; a hinge that stops on the way keeps the display it had (the cover to about 120° when opened in steps, the inner display to 20° when folded in steps);
    • UIHinge.status follows the same history, not the angle: .closed at 123° after an opening in steps, .partiallyOpen at 21° after a fold in steps;
    • opening a landscape Duo into a tent turns the cover's interface over, and there the device orientations reach the cover half a turn off;
    • the Duo ignores devicectl device orientation set, and iPhone and iPad ignore Device Hub's orientation event; the Duo's inner display shows portrait upside down, its cover and an iPhone never do;
    • the iPad turns an app whose application(_:supportedInterfaceOrientationsFor:) returns .portrait (no UIRequiresFullScreen), so the gated mask holds iPhones in portrait, not iPads;
    • touches through a virtual touchscreen land within a point of the target on every display and rotation; like a finger's, they do not reach the app under an iPhone's status bar in portrait or outside a rounded display corner.
  • From a test app's Duo fixes, measured (iphone-duo):
    • bars-and-toolbars: a full-screen overlay stays under the vertical bar, so hide its items with isHidden (gone from the bar and the accessibility tree), not isEnabled = false (still there, dimmed); a UIHostingController throws away toolbarItems set from UIKit at launch and again when the Duo unfolds; a UI test finds the vertical bar by buttons sharing a midX, since on the closed Duo in landscape-right the column is on the left.
    • layout-size-classes-safe-area: the system sheet on the Duo — closed, a card 8 pt from the sides and the bottom (450 × 390 pt in portrait); open, 653 pt wide and centred; a large sheet runs to the bottom edge. Tests wait for the hinge gate to latch: the first handler call came 0.13–0.52 s after addInteraction. A part only one layout has (a footer) goes into one copy of the screen through .safeAreaInset, not into two if/else copies.
    • testing-and-sources: IDESchemeActionDeviceRecord … invalidDigitCount(91014) in an xcodebuild log is noise; a test against the Duo runtime passes with it.
    • pose-checks: a change to a shared component needs every suite that renders it, in every pose; suites that need the open Duo run on their own, after foldsim pose open-landscape.
  • tests/foldsim-probe: the probe app and run.sh, which checks every command against what the app reports, on its own simulators, one at a time.
  • CI: a macOS job builds foldsim and runs its self-test. The validator checks that the launcher is executable and that foldsim's sources never shut down or erase a simulator.

Changed

  • iphone-duo: Verifying and testing-and-sources.md no longer say that poses, the Duo's rotation and inner-display taps are manual only; they point to foldsim, with Device Hub as the fallback.
  • hinge-scenes-camera: never map angle ranges to a hinge status or a display (measurements above).

Fixed

  • NOTICE.md still gave the inner display as 626 × 890 pt, "derived"; it now has the measured 669 × 951.

[1.3.3] — 2026-10-30

Findings from fixing iPhone Duo QA bugs in a test app. Each one was re-measured on the simulators first: Xcode 27.2 RC, Duo runtime 24B91014, iPhone 18 Pro Max and iPad Pro 13-inch on 24B114. Two of them did not reproduce as first described and were narrowed down before going in.

Fixed

  • Render tests on the Duo simulator. A window sized exactly like a Duo display is resized to the current scene, at creation and on every fold or rotation. This applies to 466 × 678 and 669 × 951, in either orientation. Other sizes, and every size on iPhone 18 Pro Max, are kept. The advice now:
    • keep the window at the scene's size and size a child container instead;
    • assert the hosted view's bounds before snapshotting;
    • create windows with UIWindow(windowScene:) — init(frame:) is deprecated since iOS 26. The mid-test resize example still said 626 → 313; it now says 669 → 334.

Added

  • Landscape for the outer display reaches every iPhone. The Duo reports .phone, so adding landscape to the iPhone UISupportedInterfaceOrientations key rotates all iPhones. New: a run-time mask behind the hinge gate, typechecked, and measured — the Duo rotates, iPhone 18 Pro Max stays in portrait. The audit flags the plist change under rule 14.
  • The 24 pt navigation-bar strip. On the closed Duo in landscape, a title-less navigation bar whose items all moved to the vertical bar still takes 24 pt at the top. With an opaque UINavigationBarAppearance this is a white strip across the top; .toolbarBackground(.hidden, for: .navigationBar) removes it.
  • Occlusion regions are not only the camera. There is also a status-bar region in the bar column. In outer landscape the camera sits in a corner of the window. The inner camera is an inactive region until a capture session uses it. iPhone and iPad report occlusion regions too, so avoiding them is not Duo-only.
  • The fold's margins. 20 pt on each long side, so the keep-clear zone is 80 pt. A design-rule note: an element that does not fit whole beside the fold moves to the other half.
  • Overlay-wrapper anti-pattern. An overlay ArrangementView around one scrolling column leaves the top half empty in the table pose.
  • isDynamicIslandLimitedInWidth (iOS 27.0) for compact and minimal Live Activities on the Duo, quoted from Apple's documentation.
  • sharedBackgroundVisibility(.hidden) for a counter that shares a button's glass capsule, in the vertical bar too.
  • Sheet geometry. System sheets on the Duo: 653 pt wide on the inner display; beside the bar on the closed landscape display.
  • Simulator tooling.
    • devicectl device orientation set rotates iPhone and iPad simulators, but not the Duo.
    • simctl io screenshot --display=1|3 captures one Duo display.
    • AXe taps land on the cover display.
    • SIMULATOR_MODEL_IDENTIFIER gives the device model in tests (iPhone19,4 for the Duo).
    • The Duo runtime ships only Safari and Settings among Apple's apps.
    • Render tests that need the fold must run on an unfolded Duo.
  • The status bar sits in the bar column on the closed Duo; content that ignores the side safe area slides under it.

[1.3.2] — 2026-10-29

Xcode 27.2 RC becomes the required toolchain, and three sarunw.com articles (2026-10-16, 10-22 and 10-26) are folded in after re-measuring everything they claim. The measurements were taken on the iPhone Duo simulator with Xcode 27.2 RC: the iOS 27.2 Duo runtime (24B91014) and the iOS 27.1 runtime (24A94425). They also exposed a wrong inner-display size that the plugin had carried since 0.9.0.

Changed

  • Toolchain: Xcode 27.2 RC or later, with the iOS 27.2 simulator runtimes (owner's decision). The gate still probes the SDK for the Duo headers first, then requires version 27.2+; Xcode 27.1 is reported as unsupported, with a link to install 27.2 RC. The gate now finds Xcodes with find instead of a glob, which zsh aborted on no match.
  • iOS 27.1 stays a supported runtime — the Duo shipped with it. New §Known iOS 27.1 bugs lists workarounds that also run on 27.2. It also explains how to keep Duo-only code off 27.1: raise the hinge gate to #available(iOS 27.2, *).

Fixed

  • The inner display is 669 × 951 pt, not 626 × 890. The old figure was the panel's 1878 × 2670 pixels divided by 3. The simulator lays apps out on 669 × 951 pt and renders 2007 × 2853 px (nativeScale 3), which is exactly the App Store screenshot size. The new figures run through the skills, the design-review rules, the Figma intake table, the designers' guide and the audit:
    • the fold band is 40 pt wide and centred at 475 pt, not 445;
    • the Split View half is now ≈ 334 pt (derived);
    • the audit now flags render tests still at 313 or 626 pt.
  • The flat fold. Talk 111463 says the inactive division region has zero width. The simulators still report the 40 pt band, so the references now say to test isActive, never the width.
  • Overlay z-order. The ArrangementView documentation sides with the HIG: "the arrangement view places the primary view above the secondary view in the z-axis". DTS forum answer 847816 is the outlier.

Added

  • contentMargins(for: .container) (ContentMarginGuide, iOS 27.1) — SwiftUI's counterpart of layoutMarginsGuide. Included: Apple's documentation, code typechecked at deployment targets 27.1 and 17.0, and a measured table of SwiftUI and UIKit margins per pose. Beside a vertical bar the margin is 0. Rule 14 caveat: on iPad the guide gives 20 pt, so a swap from .padding(16) goes behind the hinge gate.
  • Size classes inside ArrangementView panes, measured per pose on Duo and iPad. The split axis goes compact. The iOS 27.1 bug is confirmed: the view passed straight to the arrangement reads the window's size classes, and splitArrangementAxis is nil there; wrapping each child in a container works around it.
  • Placement matters. Inside a VStack, the panes kept the window's size classes on iPad and the closed Duo; as the root of a NavigationStack they got their own.
  • From the ArrangementView documentation:
    • a closed Duo in landscape shows only the primary view;
    • equal pane sizes by default;
    • the containers to keep apart (scroll view, navigation split view, grid; no navigation split view or tab view inside).

[1.3.1] — 2026-10-29

Closes the one check 1.3.0 left open: the hinge gate measured on the Xcode 27.2 RC simulators.

Fixed

  • Default layout margins — 1.3.0 said the zero default UIView margins from the iOS 27.2 release notes reach every iPhone on iOS 27.1 and later. Measured with Xcode 27.2 RC: zero only on iPhone Duo (24B91014); iPad Pro 13-inch and iPhone 18 Pro Max on iOS 27.2 (24B114) still get 8 pt. The section now says so and shows the explicit-margin fix, which leaves iPad and the other iPhones unchanged.
  • Hinge gate on iPad — no longer rests on Apple's word alone: on iPad Pro 13-inch and iPhone 18 Pro Max with iOS 27.2 neither onHingeChange nor UIHingeInteraction fired in 40 seconds, so deviceHasHinge stays false; on the Duo runtime both fire at launch.

[1.3.0] — 2026-10-29

The first release after iPhone Duo shipped (2026-10-23). It folds in everything Apple published since 1.2.1: group labs 287 (2026-10-13) and 288 (2026-10-15), Apple's DTS summary of the labs on the forums, the three 2026-09-23 forum Q&As (134 threads, 78 with Apple answers), the "Three steps to make your app shine on iPhone Duo" page, the 2026-10-05 App Store news, TN3192, and the Xcode 27.1 / 27.2 RC and iOS 27.2 release notes. Every Duo symbol was re-verified against the released Xcode 27.1 (27A9275) and Xcode 27.2 RC (27B48). Lab timecodes are the captions' on the Apple Developer page; YouTube-based recaps run about two minutes later.

Added

  • Hard rule 14 — Duo changes stay on Duo (owner's rule). The iPad app and every other iPhone keep exactly the layout and behavior they had; a split made for a sheet on Duo does not reach iPad in any form. Size classes cannot scope a change to Duo, and ArrangementView, bar priorities, minimization and bar-item icons act on every device, so Duo-only changes sit behind a latched hinge-presence gate (deviceHasHinge, SwiftUI and UIKit code typechecked at deployment targets 27.1 and 17.0). Measured on the Duo simulator: UIHingeInteraction and onHingeChange both deliver the initial state about 60 ms after the view appears. Tier 1 refactors must leave iPad and other iPhones pixel- and flow-identical, proven with before/after snapshots on both. Hard rule 3 and the "write for the whole lineup" advice changed to match.
  • App Store (device-and-platform): submitting Duo screenshots puts an "optimized for iPhone Duo" badge on the product page; from April 2027 Duo screenshots are required for apps on the iOS 27.1 SDK and every upload needs the iOS 27 SDK; app preview sizes; the App Store Connect preview tool.
  • Bars that scroll away (bars-and-toolbars): toolbarMinimizationBehavior(_:for:), toolbarMinimizationRestoration(_:for:), toolbarMinimizationSafeAreaAdjustment(_:for:), navigationItem.navigationBarMinimization — all iOS 27.0, typechecked. Navigation bars scroll away on Duo by default (lab 288); .never keeps them, .onScrollUp suits bottom-anchored content.
  • Motion and heading per display (hinge-scenes-camera): CMMotionManager.deviceMotionBody and CLLocationManager.headingBody take a view (iOS 27.0), so attitude and heading follow the display the UI is on; headingOrientation is deprecated in iOS 27.0.
  • Scroll axis against the hinge (arrangements-and-reserved-regions): Apple's own apps in a table — what shifts off the fold (Messages, App Store Today) and what scrolls through it (carousels, lists in the laptop pose, Preview's two-page mode). Arrangements nest; touches over the camera region are suppressed; the order to reach for tools in, from standard containers down to the hinge.
  • Layout (layout-size-classes-safe-area): Apple's "Three steps" list — re-read size in layoutSubviews / viewDidLayoutSubviews (not viewIsAppearing), regular width is not iPad, no device-size comparisons, full-bleed media that loses content; never override size classes; default UIView layout margins are zero on iOS 27.1+; scroll position kept by index path, and a semantic anchor for custom text; tab bar or sidebar with Apple's examples (Music, TV, Mail, Phone, Health); inspectors; what a fold does not do (onAppear does not fire again).
  • RTL, search and side menus (bars-and-toolbars): in right-to-left languages the list column sits between the vertical bar and the detail; search stays at the bottom on the inner display; safeAreaBar(edge:) with toolbarVerticalEdge for custom vertical bars; UIView.LayoutRegion.bar(onEdge:) without extent: (iOS 27.2); the launch screen cannot follow a vertical-bar opt-out.
  • Audit categories 24–26: size-class overrides (HIGH), full-bleed media set to fill (LOW / manual), motion and heading frames (LOW). Category 6 is MEDIUM now and catches statusBarOrientation; category 12 checks for a launch screen (required for App Store submission with the iOS 27 SDK) and UIRequiresFullScreenIgnoredStartingWithVersion; category 16 catches bounds.height == 844-style comparisons. The checklist has 26 categories.
  • Design rules D30–D32: the navigation model stays recognisable between closed and open; scrolling across the fold is fine and reads best perpendicular to it, while row-anchored elements such as chat bubbles shift off it; search stays at the bottom on the inner display. The set is D1–D32.
  • StandBy and widgets (systemExtraLargePortrait, Live Activities on the vertical Dynamic Island), PiP on the folded device, UIRequiresFullScreen deprecation (TN3192), Mac Catalyst build issue for iOS 27.1 APIs, Xcode 27.1 / 27.2 RC simulator and Device Hub known issues, the 27.2 runtime identifiers, reading the forums in a browser.
  • From the forum Q&As (each with the thread link): the inner camera's real capabilities (native 1080p at 30/60 fps, metadata output, long sessions, extra per-frame cleanup), what a virtual front camera switch looks like to frame processing, multicam limits, ARKit with CameraCaptureAccessory, camera availability from the direction coordinator; ArrangementView collapsing to the higher .layoutPriority child; no automatic fold avoidance for collection views and Apple's default of not moving scrollable grids; sheets moving to the leading edge when folded; a scene delegate per window; scroll content passing under the vertical bar; custom-bar accessibility (long-press labels, Large Content Viewer); hinge angle range not guaranteed; hinge-dependent games and App Review.

Changed

  • SDK tags: SDK(27.1 β1) is now SDK(27.1) — the released SDK matches beta 1 for every Duo declaration, and the documentation pages dropped "beta".
  • SDK tiers follow Apple's "Three steps" page: an iOS 26 SDK app sits centered with empty space on the open display and left of the status bar on the closed one.
  • Unverified list: Touch ID confirmed (specs page); Apple Pencil (USB-C) is supported without hover; WebKit's Viewport Segments and Device Posture APIs exist as opt-in experimental features in iOS 27.1; the extra-large widget is systemExtraLargePortrait; there is no system pose value.
  • Testing: asked about an XCUITest or simctl hook for the hinge state, Apple named none and asked for Feedback naming the use case; a physical Duo is not needed for most testing.
  • Rule 1 and rule 14 reconciled: an existing idiom == .pad branch that keeps the iPad layout may stay; converting it to a size class is allowed only when iPad and the other iPhones come out unchanged (a Pro Max in landscape has a regular width). Audit category 5, migration step 4 and the report's Opportunities now say which suggestions need the hinge gate. The UIKit gate sample latches once per app from the window instead of per screen.
  • D13 also allows immersive games and a regular-width-only opt-out where compact and regular interfaces genuinely differ (Safari's tabs); D16 sends sheets to the leading edge when folded.
  • Freshness rewritten for the shipped device: new baselines (page hashes, release-notes titles, the next lab page) and what is still open.

Fixed

  • device-and-platform said Duo screenshots had no badge and no requirement — both now exist.
  • The SDK tier table described the closed-display behavior under "inner display".
  • UIRequiresFullScreen was described as "no Split View"; no Apple source says that, and Apple's forum answer says no API prevents multitasking. It now reads "discrete resizing" only.
  • devicectl device appResize / orientation were listed as third-party and unverified; they ship in Xcode 27.0–27.2 RC (resizable app sessions and simulated orientation on a device, not a fold).
  • An unrebuilt app was said to show "no reaction to any pose"; partially open, it shifts to one side.
  • D16 said sheets move to the trailing side in the book pose; Apple says they move to the leading edge.
  • The Figma intake pointed fold-avoidance candidates at D9 (bar order) instead of D14.
  • The lab-captions recipe built …/subtitles/en//prog_index.m3u8; the CDN answers that with a 302 and an S3 AccessDenied body, so no captions came back. It now joins the path correctly and fetches the ~600 segments in parallel.

[1.2.1] — 2026-10-13

Added

  • iphone-duo testing reference: XCUITest on the open iPhone Duo simulator. XCUIApplication.frame stays portrait (669×951) while the interface is landscape (951×669), so app.coordinate(…), app.swipeUp() / app.swipeDown() and app.frame rotate gestures by 90°. Build screen-level gestures from app.windows.firstMatch. Measured with a probe test on Xcode 27.1 beta; the fold does not swallow touches. SKILL.md points to the section from its testing summary.

1.2.0 — 2026-09-30

Added

  • Native Codex packaging: portable root plugin.json and a repo marketplace at .agents/plugins/marketplace.json, sharing the existing skills with Claude Code.
  • A shared read-only audit workflow bundled inside the iphone-duo skill. Codex and skills-only installs can run the full audit without registering a Claude agent or starting a new session.
  • Codex installation, invocation, Figma MCP and Xcode MCP instructions; the designer guide now covers both hosts.
  • A dependency-free package validator used by CI: both manifests, marketplaces, skill version answers, bundled references and release tags must agree.

Changed

  • The Claude audit agent is a thin adapter to the shared workflow. The 23-category checklist, severity rules, scope handling and report format remain in their existing shared references.
  • Skills recognize standalone help/version requests in both hosts. Flags embedded in a URL or a longer task do not short-circuit the request. Version replies need no manifest lookup.
  • Audit-only requests return findings without applying fixes. Unavailable subagents fall back to the same workflow in the current session.
  • Figma intake discovers actual tool names and schemas before using provider-specific examples.

1.1.0 — 2026-09-22

Added

  • -h / --help and -v / --version on both skills. --help prints a short card — what the skill is for, what to hand it, what comes back, what it needs — and stops, without reading a repo or calling Figma. --version reads the number out of .claude-plugin/plugin.json next to the skill body, because that is the only number a skill can read at runtime — the host strips the YAML frontmatter before showing a skill, and npx skills add copies skills/ without .claude-plugin/plugin.json.
  • A CI guard for that literal (.github/workflows/version-consistency.yml): it fails when a skill's skill-version marker or its -v answer line disagrees with .claude-plugin/plugin.json, and on a tag push it also checks the tag and the CHANGELOG entry. The version now lives in three files on purpose, and drifting is a build failure rather than a wrong answer to -v.

1.0.0 — 2026-09-21

First release verified against a real SDK. Xcode 27.1 beta 1 (27A9269) shipped on 2026-09-18 with the iOS 27.1 SDK and the iPhone Duo simulator, and Apple published the developer article "Preparing your app for iPhone Duo", two camera articles, the September 2026 documentation/updates sections, the Xcode 27.1 beta release notes and two iPhone Duo Group Labs. Every Duo symbol in the references now carries an availability annotation read from the SDK, so the plugin no longer reasons about APIs it has never seen — which is what 0.x was waiting on.

Added

  • SDK(27.1 β1) provenance tag alongside VERBATIM / PROSE / CAPTION / EXISTING: where a name came from, and whether it has been confirmed in a shipping SDK.
  • Arrangement API that the talk never showed: ArrangementViewStyle (the protocol behind the transcript's "ArrangementStyle"), makeBody(configuration:), ArrangementViewStyleConfiguration, overlayArrangementEdge(_:), the four splitArrangementLayout* sizing modifiers, the splitArrangementAxis environment value, UIArrangementViewState (zIndex, splitAxis, isHidden), UIArrangement / UISplitArrangement.Dimension / DimensionRange, and UIViewController.arrangementViewController.
  • Reserved regions beyond the frame: margins, isActive, the opaque ReservedRegion.ID, and the SwiftUI query's third argument layoutDirectionBehavior: (defaults to .mirrors).
  • Hinge types: DeviceHinge / DeviceHingeContext (SwiftUICore), UIHinge, UIHingeInteraction(updateHandler:) and all four statuses — previously "verify these spellings".
  • The UIKit path for scene accessories, from Apple's article: UISceneAccessory.cameraCapture(sceneConfiguration:userInfo:), registerSceneAccessory(_:) → UISceneAccessoryRegistration, the windowCameraCaptureAccessory role, sceneAccessoryUserInfo, and the rule that Split View withdraws the accessory.
  • The camera article's code, which the talk only gestured at: the virtual front camera (isVirtualDevice, activePrimaryConstituent), resolving an AVCaptureDeviceDescriptor on a capture actor, and deciding mirroring from the direction map rather than from position.
  • Sheet placement: presentationPlacement(_:) / UISheetPresentationController.preferredPlacement (iOS 27.0) decides whether an inner-display sheet gets horizontal or vertical bars.
  • UIView.LayoutRegion.bar(onEdge:extent:) — ask the system where it would have drawn its bar instead of measuring, for the apps that genuinely cannot use a container bar.
  • backgroundExtensionEffect() / UIBackgroundExtensionView for hero art under a vertical bar.
  • Two design rules, so the set is D1–D29: D28 (a pose change moves elements, it does not rebuild the screen — Apple names "designing for every pose" as the biggest mistake they have seen) and D29 (tabs stay inside a sheet when the tabs choose the sheet's content).
  • A recipe for reading a Meet with Apple lab — those pages carry no transcript, only HLS caption segments — plus the Duo simulator identifiers, now that they exist.
  • A toolchain gate that runs first and reports as a warning, in the skill, the audit checklist and the agent. It probes each installed Xcode's iOS SDK for UIHingeInteraction.h and UIViewReservedRegion.h rather than comparing version numbers — Xcode 27.2 beta 1 (27B5019j, 2026-09-16) shipped two days before 27.1 beta 1 (27A9269, 2026-09-18) and is on a different build train, so a >= 27.1 test passes a toolchain with no Duo APIs. It also covers the common split where the Duo SDK is installed but some other Xcode is active, and answers it with DEVELOPER_DIR=…, which needs no admin rights, instead of sudo xcode-select -s. Enumeration combines the usual folders with Spotlight, so an Xcode on another volume is found. Nothing in the gate launches Xcode: versions come from Contents/version.plist, because Contents/Info.plist reports DTPlatformVersion = 27.0 even in the 27.1 beta, and running xcodebuild under a never-opened Xcode can demand sudo xcodebuild -license.

Changed

  • testing-and-sources.md is rewritten around an installed 27.1: Device Hub poses and the transitions between them, camera apps launching in Simulator without a camera, the beta's known issues, and iPhone Mirroring promoted to Apple's first-choice proxy when 27.1 is absent.
  • The freshness protocol now watches for the iOS 27.1 RC dropping "beta" from the annotations, rather than for the beta itself.
  • Both skills cite the developer article alongside the HIG, and the labs where an Apple engineer says something the written docs do not.

Fixed

  • "Inspectors do not get their own bar" — they do, horizontally, says the article.
  • "Apple never uses letterboxing" — the HIG never does, but an Apple engineer walks through the whole letterbox progression in lab 285. The claim is now attributed to the lab.
  • UIViewReservedRegion was tagged PROSE; it is a real ObjC class whose Swift name is UIView.ReservedRegion, refined from -reservedRegionsOfKind:options: — which is also why a grep for reservedRegions in the UIKit headers returns nothing.
  • CameraCaptureAccessory was filed under AVFoundation; it is a SwiftUI SceneAccessoryContent.
  • App Resizability was described as an Xcode 27 skill; it exists only from 27.1, and the export command takes --output-dir.
  • The Duo simctl device type was listed as "not published" — it is com.apple.CoreSimulator.SimDeviceType.iPhone-Duo.

0.10.0 — 2026-09-17

Line-by-line re-check of both skills against the live HIG page Designing for iPhone Duo on 2026-09-16 (change log still "September 9, 2026 — New page").

Added

  • hig-design-review — nine Duo design rules for HIG guidance that had no checklist entry, so the set is now D1–D27 (ids are stable; new rules append). D19 controls stay near the content they affect · D20 Split View puts each app's controls on its outer edge, layouts are asymmetric · D21 bars do not mirror in right-to-left languages · D22 toolbar vs tab bar under compression · D23 full-width background with inset content is allowed (guards against a false D8/D13 finding) · D24 alerts, context menus, sheets and split views adapt to the fold by themselves · D25 split vs overlay arrangement · D26 navigation stays outside an arrangement view · D27 games.
  • iphone-duo — bars-and-toolbars.md §"Not everything belongs on the bar" (a control that acts on another column stays with that column); the outer camera is vertically aligned with the side controls; arrangements-and-reserved-regions.md records that an overlay arrangement can collapse its secondary view, tagged PROSE because Apple publishes no spelling for it.

Fixed

  • hig-design-review — five citations that pointed at text Apple never published: a fabricated quote in the Figma comment template ("content and controls that span the fold become harder to see"), the same invention in the example findings row, a "Support Split View" best practice that does not exist, D9 anchored to the hardware "Anatomy" section instead of "Follow the standard placement order for toolbar items", and D10–D12 labelled "HIG Do" although the page has no Do/Don't blocks at all. Every rule now quotes the page verbatim or paraphrases without quotes, and the report template says so.
  • hig-design-review — the games guidance moved out of "What Apple does not say" (Apple does say it) into rule D27, with the two clauses that were missing: keep text and control sizes consistent when resizing, and fill unavoidable padding with artwork.
  • hig-design-review — D17 now carries the HIG's own wording for the outer camera region ("expands into the Dynamic Island for Live Activities") and its alignment with the side controls.
  • Both skills — every tech-talk citation re-checked against the official Apple transcripts of the six "Get ready for iPhone Duo" talks (111461–111466). All 46 VERBATIM code blocks matched Apple's 46 sample-code blocks exactly, at the same timecodes, with none missing on either side, and every cited timecode landed on the right chapter. Twenty prose quotes turned out to be paraphrases wearing quotation marks and now carry the speaker's own sentence plus the exact timecode — among them the reserved-region and displacement definitions, the arrangement definition, the fold avoidance behavior, the safe-area guidance, the SDK tiers, the Device Hub controls, and the camera-direction passage. Where Apple has no matching sentence the quotation marks are gone.
  • iphone-duo — the UIRequiresFullScreen paragraph attributed its quote to a WWDC26 278 chapter title that does not exist; session 278 is "Modernize your UIKit app" and the sentence is spoken at 6:00 inside the chapter "Full-screen mode for games". Quote and anchor corrected, and the session's own "no longer opts your app fully out of resizing" replaces the second-hand caption note.
  • hig-design-review — D14 said the talk calls fold-spanning content "a photo spread across a book's spine"; 111463 1:44 actually shows "this photo spread across the two pages", which when folded "no longer reads as one continuous image". 111466 9:51 says "curve region", not "hinge".
  • iphone-duo — the source table claimed the talk pages carry "chapter text + Code sections (not transcripts)". They carry the full official transcript inline in the HTML; testing-and-sources.md now has a §Read a talk recipe that pulls transcript and sample code with two greps, no JavaScript. Consequences recorded: PROSE now means "spoken in Apple's official transcript", the six CAPTION spellings are confirmed wrong by that transcript, UIWindowSceneActivationAction was a truncated caption rather than an Apple misspelling, ArrangementStyle joins the PROSE table, and the transcript's singular "reservedRegion method" is flagged as losing to the Code section's reservedRegions(kind:).

0.9.0 — 2026-09-14

First public release.

Added

  • Skill iphone-duo — adapting Swift apps (UIKit + SwiftUI) to iPhone Duo: size classes, vertical bars, reserved regions, arrangement views, hinge, multiple scenes, dual front cameras, Split View, adaptive layout and state continuity. Seven reference files, Apple's 13-step migration order, and a status tag (VERBATIM / PROSE / CAPTION / EXISTING) on every new symbol.
  • Skill hig-design-review — reviewing Figma or Sketch mockups against the Human Interface Guidelines before implementation: general iOS checks plus the iPhone Duo rules D1–D18, with live HIG citations, a Ready / Not ready verdict and optional Figma comments.
  • Agent iphone-duo-audit — read-only readiness audit that runs the 23-category grep checklist over an iOS codebase and returns a severity-ranked report with file:line and fix pointers.

Notes

  • Research date 2026-09-10; statuses re-checked against the iOS 27.0 SDK (Xcode 27.0 RC) on 2026-09-14. The Xcode 27.1 beta had not shipped, so no iOS 27.1 symbol carries an official availability annotation yet — the skills say so and gate new APIs behind a toolchain check.