Skip to content

Source Model — The segment editor: CRUD on every surface, no mode gate, nothing lost — Design Spec (#6413, #6412)

Milestone: segment-editor Manual: the user manual’s “Editing the lines” section (tracked by segment-editor.md) gains the Edit › Segments ▸ submenu, the context menus and the shortcuts once built.

Design-led (Testing Constitution). The creative director owns this intent; tests enforce it; code makes them pass. Status: DRAFT — written 2026-11-08 by the spec writer from the owner’s dev-build findings (#6413), the marquee grain finding (#6412) and the manager’s rulings of 2026-11-08; the manager reads the steps before approval. A companion to segment-editor.md (APPROVED 2026-10-26), which it does not change: it adds behaviours for what the owner found missing and cuts them into steps. The review that produced it is agent-work/status/briefs/segment-editor-review-2026-11-08.md. The focused-pane behaviour (#6476) lives in source/panes.md as source.panes.focused-pane-is-plain; Step 1.25 here no longer lists it.

Intent

A person selects regions or lines anywhere, the Preview, the Inspector, the Segments pane or the Reader, and can create, edit, join and delete them from the same menu, context menu, shortcut and icon, each as one audited action with one undo, with no mode to enter first. Several marquees added at once are one action with one undo. Reading levels are seen, compared and chosen, and the working text is the person’s. The hierarchy is selectable up to the page and down to the children; Split has a door; the Preview has a Reader bar and an Editing bar; the next step runs on the selection.

Decisions (owner 2026-11-08, DECIDED, after the Fable reviews in agent-work/status/briefs/fable-segment-reviews-2026-11-08.md)

  1. “Segment” is not a level. The ladder is stroke › character › word › line › region › page; “segment” means any level of it. Every ladder in this spec and its briefs reads so; Step 1.12’s parent-kind table follows the ladder.
  2. Deleting a region with lines always asks: with its lines, lift its lines, or cancel. No door deletes a parent’s children silently (Step 1.9’s region header Delete included).
  3. In the Reader, ⌘A selects the LINES of the page as the shared selection; the separate ⌥⌘A is dropped in the Reader (it stays elsewhere as proposed). A focused text field keeps ⌘A for its caret.
  4. Edit Shape takes a free chord found by MenuShortcutUniquenessTests; ⌥⌘E is taken (show or hide zoom controls, PreviewHeadControls.swift:186) and is not it.
  5. Reading levels (#6429, 13:10). As written is the DEFAULT working text, not always: the person compares levels and can change which level is the working text, and the next step reads the working text. The levels are seen side by side: working text | normalised or modernised | translation. The level actions get chords, proposed and checked by the uniqueness rule.
  6. Colour (#6419, #6422, 13:10). The hue is the REGION’s, a stable hash of its id and kind; the shade ramps WITHIN a region by the segment’s place in that region’s order; the page order shows by the order of the regions. This supersedes the page-wide ramp written earlier on 2026-11-08 and the 2026-10-04 colour sentence of segment-editor.md.

Rulings (2026-11-04 to 2026-11-08)

  • Owner 2026-11-08 13:10 (#6419, #6422), DECIDED, superseding the manager’s page-wide ramp of the same day and segment-editor.md’s 2026-10-04 colour sentence (“region hues assigned in region reading order”; RegionColours.swift: “no hash of an id picks a colour”): the HUE is the REGION’s, a stable hash of the region’s id and kind (regions have colours), never a position or index; the SHADE ramps WITHIN a region by the segment’s place in that region’s order; the page order shows by the order of the regions.

  • Owner 2026-11-08: full CRUD for regions and segments, each one audited action with one undo, reachable from context menus on every surface, a menu-bar home, a keyboard shortcut and an icon each; a table of operations × doors checked for shortcut uniqueness.

  • Owner 2026-11-08: segment verbs act whenever segments are selected; no mode first.
  • Manager 2026-11-08: the menu-bar home is Edit › Segments ▸, a submenu, not a top-level menu; the same items, shortcuts and icons in the context menus on every surface.
  • Inherited from segment-editor.md: 2026-10-04 (#5114) no new mode, the tool bar; 2026-10-04 (#5115) the Inspector runs the same one-path verbs, never a second implementation.

Behaviors

  • source.editor.n-marquees-one-audit-one-undo — [GAP] (#6412, #6413; owner 2026-11-08 and lane-ie’s run 2026-11-08: boxes drawn as regions ARE kept. The app’s flow is one PUT /api/artifacts/{id}/regions with op=add per marquee, and that route already converts the page and writes SEGMENT rows through segment.convert_and_edit (artifacts.py edit_artifact_regions, “one audited, undoable action per edit”), so three marquees gave three segment rows, three audit rows and three undos. Not a loss; the gap is the grain) adding N marquees at once (▶ on a set of marquees, or New Region over several) is ONE create batch on the page’s segment pass through the existing segment path, segment.create_many after the page’s one conversion when it is result-only, ONE audit row and ONE ⌘Z for the N regions, never N calls and N audit rows; the other way, the regions route (PUT /api/artifacts/{id}/regions, whose _edit_regions_impl takes ONE edit) taking a list of edits, is named and not taken: that route converts and then writes segments, so the batch through the segment path keeps artifact and segments in step by the same conversion; and the Fable review’s note that segment.create_many does not place new rows in the as-written order (unlike segment.create, _place_in_as_written) is part of this step: the batch places each new segment in the page order as a single create does; a single marquee stays one action as today. The Segments store is re-read once after the batch and the N regions are drawn, listed and selected together. Unverified, to reproduce on a scratch library before any claim of loss: a page whose shown pass has a RESULT artifact (not a bare regions artifact), where RegionEditTarget’s third clause may refuse or route differently; if regions vanish there it is a separate finding, recorded on #6412 with the steps that show it. Acceptance: draw three marquees and press ▶ once: three segments appear in the Segments pane and the Inspector, the audit shows ONE row naming three, one ⌘Z removes all three; the red test on base shows N adds give N audit rows. Test: test_n_marquees_one_audit_row_6412.py (not yet written; fails on base: N adds, N audit rows), PreviewSegmentCrudTests.swift (not yet written).

  • source.editor.delete-deletes-the-segment — [GAP] (#6419; owner 2026-11-08, lane-ie fixing: deleting a segment in the Preview on a page whose shown pass has an artifact removes only its box from the regions artifact (deleteSelectedRegions → ArtifactService.deleteRegions, ArtifactService+RegionCuration.swift), the segment row stays and comes back; only an artifact-less pass takes deleteSelectedSegments) Delete in the Preview deletes the SEGMENT on every page: SegmentDeleter’s one audited segment.delete batch, one audit id, one ⌘Z, the same plan every other surface runs (source.editor.select-all-then-one-delete), converting a result-only page first as the other verbs do; the regions-artifact delete is not a door for a segment. In the Reader likewise (manager 2026-11-08): the Lines mode already deletes through SegmentDeleter (ReaderLinesView.deleteLines); every other Reader segment surface, the strip, Immersive (Page/Immersive/*) and MultiSelectionReaderView, deletes the SEGMENT through the one item table and SegmentDeleter, never only a reading (a reading emptied by typing stays leftOut, the text mode’s rule, and is not a delete). Acceptance: on a page with an artifact, select two regions in the Preview and press ⌫: the two segments are gone from the Segments pane and the Inspector and stay gone after reopening; one ⌘Z brings both back; the audit shows one row. Test: test_preview_delete_deletes_the_segment_6419.py (not yet written; fails on base), PreviewSegmentCrudTests.swift (not yet written).

  • source.editor.no-mode-gate-selection-is-the-edit-state — [GAP] (#6413; owner 2026-11-08: segment editing and Join show only after the metadata icon and Edit Segments; ruled: available whenever segments are SELECTED. Code: WindowState.isEditingSegments gates the menu (SegmentMenuCommands.swift, Delete, Join and the attributes .disabled(!editing), “Turn on Edit Segments to change segments”), the Preview handlers (ZoomableImagePreviewMac+Regions.swift:92, 102, 163, 195, +SegmentEdits.swift:85 nudge, RegionInteractionLayer+Reshape.swift:11), the PDF page (PDFPageWithToolbar+SegmentEdits.swift:18), toggled at ZoomableImagePreviewMac+Overlays.swift:144) a selection IS the edit state: select, delete, join, the attributes and nudge act on the selected segments with no mode first, on every surface, and the menu’s reason reads “Select segments on the page” and nothing about a mode; the gate is removed at every site above. What remains of Edit Segments is the SHAPE tool, renamed Edit Shape: drawing a new shape by hand and the reshape handles on the selection, a tool-bar state like the markup tools (the 2026-10-04 ruling on #5114: the tool bar, no new mode), never a precondition for a verb; New Region and New Line need no tool. Acceptance: click a region on a fresh page, press ⌫: it is deleted with one ⌘Z and no mode was entered; select two lines, ⌘J joins them; with nothing selected the items are disabled with “Select segments on the page”. Test: SegmentVerbsNeedNoModeTests.swift (not yet written; the menu’s enabled state and reason as a pure function of selection count with no editing flag; each handler’s guard gone), the existing RegionSelectionTests.swift.
  • source.editor.right-click-selects-first-double-click-edits — [GAP] (#6413; owner 2026-11-08. Code: a double-click on a box opens the segment POPOVER, picture large and text (RegionInteractionLayer.swift:424, +SegmentPopover.swift, preview.segment.double-click-popover, OK, #5414), or onOpenRegion when none; reshape handles begin only in Edit Segments (RegionInteractionLayer+Reshape.swift:28); a right-click shows ONE canvas menu (ZoomableImagePreviewMac+Regions.swift:180/188 regionContextMenu: Add Region…, Clear Selections, New Region from Selection… gated) that neither selects the box under the pointer nor offers a segment verb) with no tool and no mode: a RIGHT-CLICK on a segment selects it first, unless it is already in the selection, which stays, and shows the one item table (source.editor.crud-one-action-each-every-door); the canvas menu’s items fold into that table (Add Region… is New Region, New Region from Selection… is Group, Clear Selections stays), nothing gated; a DOUBLE-CLICK on a segment opens its EDIT: the shape handles on its box (the reshape guard goes with the gate) and, where the segment has text, its text field in place, the #5414 popover BECOMING that edit state’s text field (its Reader row, editable, over the handled box) so one component serves view and edit; onOpenRegion stays for a region node with no segment; Escape leaves the edit. Note on preview.segment.double-click-popover (OK): its view becomes its edit; not rewritten here. Acceptance: right-clicking an unselected line selects it and the menu offers Join, Split…, Delete and the rest; right-clicking one of three selected lines keeps the three and the menu acts on them; double-clicking a line shows its handles and its text ready to type, no mode entered. Test: SegmentVerbsNeedNoModeTests.swift (the Step 1.2 test: a right-click’s selection rule; the double-click’s handles with no editing flag), the existing RegionSelectionTests.swift.
  • source.editor.crud-one-action-each-every-door — [GAP] (#6413; owner addition 2026-11-08) the segment editor has full CRUD for regions and segments, each operation ONE audited engine action with ONE undo (Select All: app state; New Region and New Line: segment.create_many; Edit Shape and Nudge: segment.update; Kind, Direction, Furniture: segment.update_many; Join: segment.merge; Delete: segment.delete, SegmentDeleter’s one batch), each ONE Swift component rendered by every door: the Edit › Segments ▸ submenu, the context menus of the Preview’s image page AND its PDF page (Views/Preview/PDFViewer/PDFPageWithToolbar*, PDFPageView+OCRBoxes: the same table, New Region, New Line, Split, Join, Delete and the attributes on a PDF page’s boxes, its gate at PDFPageWithToolbar+SegmentEdits.swift:18 removed with the others), the Inspector, the Segments pane and the Reader’s lines, one keyboard shortcut and one icon each, as the table in agent-work/status/briefs/segment-editor-review-2026-11-08.md lists them (shortcuts proposed: ⌥⌘A Select All Segments outside the Reader, where ⌘A is it (decision 3); ⌥⌘N New Region; ⌥⇧⌘N New Line; Edit Shape a free chord found by the uniqueness test, not ⌥⌘E (decision 4); ⌘J Join as today; Delete has ONE keyed home, Edit › Delete ⌘⌫ (ui/menus-and-commands.md, the item verbs’ Delete), the Segments submenu’s Delete carries no second chord and ⌫ on a surface stays the existing routing rule, text first; the uniqueness test decides every chord); a disabled item says why under it, as Page › Segments already does. Acceptance: ONE item table (not a count: Split, Run the next step, Correct This Line… and Create Named Order join it), in the same order with the same icons, appears in Edit › Segments ▸ and in every context menu; each acts on the focused surface’s selection through the one component; one ⌘Z after any of them. Test: SegmentDoorsAgreeTests.swift (not yet written; the item list is one table rendered by every door; the shortcut set is unique by MenuShortcutUniquenessTests’ rule), the existing MenuShortcutUniquenessTests.swift. Was: “⌘J Join as today”; ruled 2026-11-08 by the owner’s standard-chord rule (the manager, ui/menus-and-commands.md review section 4): Join is ⌥⌘J, and ⌘J, a standard Finder and editor chord, leaves; the table and MenuShortcutUniquenessTests carry it.
  • source.editor.edit-segments-submenu-and-doors — [GAP] (#6413; ruled by the manager 2026-11-08) the segment operations live in the Edit menu as a SUBMENU, Edit › Segments ▸, not a new top-level menu and no longer under Page (Page › Segments’ SegmentMenuContent moves, one component); the submenu is the same SegmentMenuContent the context menus render; menus.context-matches-bar and menus.no-hand-rolled-duplicates hold. Acceptance: Edit › Segments ▸ lists the operations; Page has no Segments item; a context menu on a segment in the Reader shows the same list. Test: SegmentDoorsAgreeTests.swift (not yet written), the existing PageMenuTests.swift.
  • source.editor.arrows-move-the-segment-selection — [PARTIAL] (#6457; owner 2026-11-08; pinned by fichero/Tests/Unit/general/Models/SegmentSelectionStepTests.swift) with segments selected, Up and Down in the Preview move the selection to the previous or next segment in the shown pass’s reading order, as Finder’s do, Shift adds the next one beyond the far end, and nothing wraps: at the edge the key keeps its other job (panning, paging). The move goes through InspectorPath.select, the one seam, so the Preview box, the Reader line and the Inspector follow at once. Plain arrows are no menu chord, so the #6435 chord audit has nothing to resolve; an armed shape point’s nudge still takes the arrow first. The Inspector’s Order list is a SwiftUI List, which moves its own selection with the arrows; not yet seen in the app, and no UI test yet (the failing-first test is the pure stepping rule).
  • source.editor.arrows-step-from-the-inspector — [PARTIAL] (#6457, owner 2026-11-09: with a segment selected in the Inspector, Up/Down did nothing; a note on source.editor.arrows-move-the-segment-selection, acceptance untouched; pinned by SelectionStepsAcrossSurfacesTests.swift) the Segment Inspector steps the shared selection with Up/Down through InspectorPath.stepSelection, the one function the Preview also calls; Shift extends; a reading being edited keeps its arrows. Not yet done: the Segments and Order lists’ Shift-extend (single-selection List) and the Reader Lines/Content. Seen only through the unit test; no worker can press the key in a window. Spec change: 2026-11-09, new bullet only. Built 2026-11-09: the Reader’s Lines list steps the same selection with Up/Down and Shift (ReaderLinesView, the same InspectorPath.stepSelection); seen only in a window. Note 2026-11-17: the step goes through the order the lists show (SegmentStore.orderShownByDocument, #6422), the page’s other boxes after it as written, so after a reorder Up and Down go where the list on screen says (InspectorPath.stepOrder, pinned by SelectionStepsAcrossSurfacesTests.stepsFollowTheOrderShown); before, they stepped by the boxes as written.
  • source.editor.shift-arrows-extend-in-the-lists — [PARTIAL] (#6457; a note on source.editor.arrows-step-from-the-inspector, acceptance untouched; pinned by SelectionStepsAcrossSurfacesTests.swift) Shift+Up/Down in the Segments and Order lists add the next segment to the shared selection through InspectorPath.stepSelection, the one function every surface calls; plain arrows stay the list’s own; the list’s own highlight stays one row. Not built: Left/Right in nested outline rows. Seen only through the unit test; no worker can press the key in a window. Spec change: 2026-11-09, new bullet only.
  • source.editor.arrows-start-the-selection-from-nothing — [PARTIAL] (#6474, owner 2026-11-09: arrow keys did nothing in the real window on the M4; a new bullet beside source.editor.arrows-step-from-the-inspector, acceptance untouched; pinned by fichero/Tests/Unit/general/Models/SegmentSelectionStepTests.swift and, in a window, fichero/Tests/UI/general/Reader/ReaderArrowKeysUITests.swift) with no segment selected, Down in the Segment Inspector and the Reader’s Lines list selects the first segment in reading order and Up the last, as Finder does, instead of doing nothing; the Preview keeps Up/Down for panning and paging (startsFromNothing is off there). Built: the pure InspectorPath.stepped. Not built or not seen: the window test is written and has not been run, so the cause of the owner’s report is not confirmed there; Edit › Mark Unclear has no menu item at all since 180e3fd4c8 removed it (nothing published a reader selection).
  • source.about.names-the-build-commit — [PARTIAL] (#6474; pinned by fichero/Tests/Unit/general/Views/About/AboutInfoTests.swift) the About box shows Build <short commit> and the Save Logs support header has a Build: line, both read from the FicheroBuildSHA Info.plist key that scripts/stamp_engine_version_into_app.sh writes at embed time (unknown, and no About line, outside a git checkout), so a screenshot or a log names the build that ran. Not built: the macOS crash report’s own header, which the system writes.
  • source.editor.seeded-order-nests-lines-under-regions — [PARTIAL] (#6425; the build of source.editor.inspector-lists-each-segment-once, owner 2026-11-08: the document Inspector lists each segment twice; pinned by fichero-server/tests/unit/api/test_reading_orders.py::TestSeededOrdersNest, fichero-server/tests/unit/workflows/test_a_converted_pass_nests_lines_under_regions_6425.py and SegmentHierarchyTests.testALineListedBesideItsRegionIsShownOnce) an as-written order seeded for a page (by reading_order.create or by a result becoming a pass) puts a line’s entry under its region’s entry, so the sidebar’s layout order lists region > line, each once. An order stored flat before this (a line beside its region) is left as stored, not migrated: the Segments outline shows a line whose region is also listed once, under the region, so no on-open migration is made and the uuid5 ids are untouched. Seen only through the unit tests. Built 2026-11-09: a region’s lines follow the stored order’s own sequence where it lists them (SegmentsPane.outline; SegmentHierarchyTests.testARegionsLinesFollowTheStoredOrdersSequence), so a person’s reorder is not lost under the region.
  • source.editor.reading-field-fills-the-pane — [PARTIAL] (#6449; pinned by fichero/Tests/Unit/general/Views/Inspector/InspectorReadingFieldHeightTests.swift) the Inspector’s reading field (Edit… on a reading) is as tall as the pane gives it, less the Save and Cancel row, and never under 120 points; it follows the container’s height, not a line count (the old field was a TextField of one to six lines). Not yet seen in the app.
  • source.editor.segments-submenu-in-edit — [PARTIAL] (#6413; part a of Step 1.2, pinned by fichero/Tests/Unit/general/App/SegmentEditMenuTests.swift) the Page menu’s Segments section is now Edit › Segments ▸ (Select All Segments, Delete, Join ⌥⌘J, the attribute items, then the line verbs); Page has no Segments item. Not yet built: New Region, New Line, Edit Shape, Split…, Group and Ungroup in the submenu (their actions are Step 1.4), the context menus rendering the same list (Step 1.2 part b), and the gate removal for Join and the attribute items.
  • source.editor.verbs-need-no-mode-built — [PARTIAL] (#6413; part b of Step 1.2, the build of source.editor.no-mode-gate-selection-is-the-edit-state, whose text stays as written; pinned by fichero/Tests/Unit/general/Views/Preview/SegmentVerbsNeedNoModeTests.swift, SegmentEditingModeTests.swift and fichero/Tests/Unit/general/App/PageMenuTests.swift) delete (⌫ and Edit › Delete), join, the attributes, promoting a marquee or words, the nudge of a shape point and the context menu’s segment items act on the selected segments with no mode first: the Edit › Segments ▸ items and the markup row’s Delete and Combine follow the selection count alone, and the menu’s reason reads “Select segments on the page” with nothing about a mode. Edit Segments is renamed Edit Shape in the menu and stays a tool for drawing a new shape by hand and dragging a box (shapeDrawsSegment, pressStartsMove) and for the reshape handles. Not yet built: right-click selecting the segment under the pointer, a double-click opening its edit, the one item table in the four context menus, and the PDF page’s mode flag (it still gates only the reshape handles). Seen only through the unit tests; the app builds.
  • source.editor.delete-segment-on-the-standard-chord — [PARTIAL] (#6413; owner 2026-11-08: no shortcut to delete a segment) Edit › Delete (⌘⌫) deletes the selected segments when the Preview holds the focus and has segments selected, else the selected items as before; the segments’ Delete needs a selection and no Edit Segments mode, and the submenu’s Delete carries no chord of its own. The title names the count. Seen only through the unit tests (SegmentEditMenuTests); undo is the audited segment.delete batch’s, as before.
  • source.editor.select-all-then-one-delete — [GAP] (#6413; owner 2026-11-08: the document Inspector has no way to select ALL its segments and delete them in one action) Select All Segments selects every segment of the page (regions and lines, the working pass) from the Inspector, the Segments pane, the Reader’s lines and the Preview (RegionSelection.selectAll, the one shared selection, source.editor.selection-shared), and Delete on that selection is SegmentDeleter’s ONE audited segment.delete batch, one audit id, one ⌘Z, with the Inspector’s count (“Delete 112 Segments”) and the engine’s refusal in words when a line cannot go. Acceptance: in the Inspector of a page with 112 segments, Select All Segments then Delete removes all 112 in one step, the Preview and Segments pane empty together, one ⌘Z brings all 112 back. Test: SelectAllThenDeleteTests.swift (not yet written; through the real RegionSelection and SegmentDeleter.ids), the existing RegionSelectionSelectAllTests.swift.
  • source.editor.add-region-and-line-from-anywhere — [GAP] (#6413; owner 2026-11-08: editing and making segments in the Preview is hard; wanted clear ways to ADD a region and a segment, edit, and see them saved) New Region and New Line are offered everywhere the doors are (source.editor.crud-one-action-each-every-door): from the Preview a drag with the Shape tool draws the shape (source.editor.draw-shapes, source.editor.make-new-in-the-preview), from a menu or the Inspector New Region makes a region at the page’s centre or around the selected lines and New Line a line inside the selected or pointed region, each selected at once with its handles shown for Edit Shape, each saved through the existing segment path (segment.create_many, one batch for several) and SEEN saved: the new row appears in the Segments pane and the Inspector with “saved” state from the store, never from the view’s memory. Acceptance: Inspector › New Region adds a region that is listed, selected, reshapeable, and still there after reopening; New Line inside it adds a line in reading order. Test: PreviewMakeNewSegmentTests.swift (not yet written, the planned one), PreviewSegmentCrudTests.swift (not yet written). Built note (#6412, engine half): a region and a line made with segment.create on a pass are still rows after the library is closed and opened again, listed for the document, one audited create each, one undo (test_preview_added_segments_persist_6412.py, passes on base). The Inspector/menu doors are not built; the status stays GAP. The Preview draw side is built (DrawTarget, DrawTargetTests.swift; see source.editor.draw-shapes), seen only through the unit test until the app run.

  • source.editor.hierarchy-selectable-with-verbs — [GAP] (#6413, #6415; owner 2026-11-08: the Inspector must let you select segments with the hierarchy shown, up to the page and down to the children, and act on the selection. Code: InspectorPath walks a selection’s parents; the Inspector’s Order section lists the inspected segment’s children (SegmentInspectorView.swift:169); the Segments pane drills down only (SegmentsPaneView.parentId, Open); nothing selects a level or the page) the Inspector shows the selection’s place in the hierarchy stroke › character › word › line › region › page (“segment” is any level, decision 1) as one section, “Where it sits”: the path UP to the page, one row per level, and the children DOWN, one row per child; every row is selectable (click, ⇧ for a range, ⌘ to add) and selecting a row makes it the shared selection (source.editor.selection-shared: the Preview lights it, the Segments pane shows it), a parent row selecting its children with it as the drawn hierarchy already lights them (ruled A, #5426); every row carries the same item table as every other door (source.editor.crud-one-action-each-every-door), so Join, Split, Delete, New Line and the attributes act on the level chosen, and the page row offers the page’s verbs (Ignore this page, source.read.page-with-no-regions-is-skipped-and-says-so in models-chains-and-projects.md). The Segments pane gains Up beside its drill-down and the same selectable path. No new route: the rows are the Segments store’s parents and children. Acceptance: with a word selected in the Preview the Inspector shows page › region › line › word with the word lit; clicking the region row selects the region and its lines light; right-clicking it offers Join, Split…, Delete and New Line; the page row offers Ignore this Page. Test: InspectorHierarchyTests.swift (not yet written; the rows from a segment tree through the real InspectorPath and store, the selection after a click, the item table on a row), the existing InspectorPathTests.swift.

  • source.editor.inspector-lists-each-segment-once — [GAP] (#6413; owner 2026-11-08: the Inspector lists the same segments twice. Two sources in code, which one the owner sees to be confirmed in the app: (A) SegmentInspectorView.swift draws the path and hierarchy from InspectorPath (to, common, kindCounts over the page’s segments, around lines 54–57 and 342) and BELOW it a second ReadingOrderList(parentSegmentId: inspected, hidesWhenEmpty) lists the inspected segment’s children again from ReadingOrderStore (around line 171); (B) SourceSectionView.swift:79, the Order mode’s ReadingOrderList(nests: true) lists lines nested under regions while the flat segment list lists them too) the Inspector has ONE list of the page’s segments, the hierarchy of source.editor.hierarchy-selectable-with-verbs (the InspectorPath tree, children nested under their parent), and every segment appears in it ONCE; the Order section is no longer a second list: its reorder verbs (drag, ⌥⌘↑↓, renumber; ReadingOrderList’s moves through ReadingOrderStore) act ON that tree’s rows, in the page order (source.editor.orders.the-page-order-is-chosen-and-badged), so the one tree is both the hierarchy and the order; the Source section’s Order mode nests the same way and does not list a line twice. Acceptance: a page of two regions and nine lines shows nine line rows under two region rows and no line elsewhere in the Inspector; dragging a line row re-places it in the page order with one ⌘Z; switching the Source section to Order changes the sort, not the count. Test: InspectorHierarchyTests.swift (not yet written, the Step 1.5 test: each segment id once across the Inspector’s rows; the reorder verbs on a tree row), the existing ReadingOrderStoreTests.swift.
  • source.editor.colour-by-id-shade-by-page-order — [GAP] (#6419, #6422; manager 2026-11-08. Code: RegionColours.tones assigns the hue by first-appearance order and the strength by the sibling’s position, and no caller passes it the page order, so the ramp restarts in every region and a delete or a reorder recolours the neighbours) a segment’s colour has two parts, each from one rule: the HUE is its region’s, chosen by a stable hash of the region’s id and kind over the palette (SelectionStyle.regionPalette), never by position or index, so a page draws the same every time, a deleted or moved region changes no other region’s hue, and two regions on a page rarely share one (the hash’s spread over the palette, stated as the test’s bound); the SHADE is the segment’s place in the PAGE order (source.editor.orders.the-page-order-is-chosen-and-badged: the working pass’s as-written or the chosen order) as ONE smooth ramp from the first segment to the last across the whole page, not per region, so where one region’s last line sits before the next region’s first is seen; the legend says what it shades by (“shaded by the page order, as written by “), the Preview’s order numbers agree with the ramp, choosing another page order re-shades, and every surface reads the one Tone as today (RegionColours, SelectionStyle.regionColour). Acceptance: deleting the second of four regions leaves the other three’s hues as they were; the shade runs light to dark from the page’s first line to its last across all regions; two orders give two ramps. Test: the existing RegionColoursTests.swift extended (hue stable under delete and reorder; the hash’s spread; one ramp over a two-region page in the page order), BoxColourThroughTheStoreTests.swift. Was: the page-wide ramp above is superseded on 2026-11-08 13:10 by the owner’s decision (Decisions, item 6) and by source.editor.colour-by-region-shade-within-it below; its text is kept as written.
  • source.editor.colour-by-region-shade-within-it — [GAP] (#6419, #6422; owner 2026-11-08 13:10, DECIDED (the Decisions section, item 6), replacing source.editor.colour-by-id-shade-by-page-order’s page-wide ramp, which stays above as written and superseded. Code: RegionColours.tones assigns the hue by first-appearance order and the strength by the sibling’s position, and no caller passes it an order, so a delete or a reorder recolours the neighbours and the ramp does not follow the page order) a segment’s colour has two parts, each from one rule: the HUE is its REGION’s, chosen by a stable hash of the region’s id and kind over the palette (SelectionStyle.regionPalette), never by position or index, so regions have colours of their own, a page draws the same every time, a deleted or moved region changes no other region’s hue, and two regions on a page rarely share one (the hash’s spread over the palette, stated as the test’s bound); the SHADE ramps WITHIN the region, from the region’s first segment to its last in that region’s place in the PAGE order (source.editor.orders.the-page-order-is-chosen-and-badged: the working pass’s as-written or the chosen order), so a region’s own reading order is seen in its shades and the page order is seen by the order of the regions (the Preview’s order numbers, source.editor.orders.seen-on-the-page-three-ways, carry the page-wide sequence); the legend says what it colours and shades by (“one hue per region; shaded by the page order within each region”); choosing another page order re-shades, deleting or reordering never changes a hue; every surface reads the one Tone as today (RegionColours, SelectionStyle.regionColour). Acceptance: deleting the second of four regions leaves the other three’s hues as they were; within a region the shade runs light to dark from its first line to its last; the next region starts its own ramp in its own hue; two page orders give two shadings. Test: the existing RegionColoursTests.swift extended (hue stable under delete and reorder; the hash’s spread; a ramp per region over a two-region page, following the page order inside each), BoxColourThroughTheStoreTests.swift.
  • source.editor.hover-and-selection-keep-the-region-colour — [PARTIAL] (built 2026-11-11 on the image Preview, not yet seen in the running app: a hovered and a selected box are drawn in their region’s hue at full strength (SelectionStyle.stroke(_:emphasized:), wash, hover), desaturated toward the dimmed grey in a window that is not key, the accent only where a box has no region; the region box of a hovered or selected line is outlined in its hue (DocumentOverlay.litRegions); Show Text on Hover (off by default, after a 0.6 s rest) and Show Text of the Selection (up to three selected boxes) are Display-menu switches (HoverReadout). Test: RegionHueSelectionTests.swift, HoverReadoutTests.swift. Not built: the PDF Preview’s boxes; #6419, #6422; owner 2026-11-11: “when you hover or click on one, the colour of the box doesn’t match the colour of the region”, “I mean region box”, and the hover “is not very Mac-like; certainly should be an option in the metadata icon”. Code: SelectionStyle draws a hovered box with hoverBase (the accent) and a selected one with stroke(emphasized:)/washBase (the accent, or grey in a window that is not key), never the box’s region hue (RegionColours); a line’s region box is not lit when one of its lines is; the hover readout (OCRGeometryOverlay, the box’s text in a floating label) shows at once on any box under the pointer and cannot be turned off) a hovered or selected segment is drawn in its REGION’s hue (source.editor.colour-by-region-shade-within-it), stronger than at rest: hover a firmer outline and a faint wash, selection a heavier outline and a wash, both in that hue; a window that is not key still dims the selection as Finder does (the hue desaturated, never replaced by the accent); and the segment’s REGION box is lit with it (its outline in the same hue, at hover strength), so which region a line belongs to is seen on the page whatever the region shading shows at rest. The text readout is a Display menu (the metadata icon) switch, Show Text on Hover, off by default, and when on it waits for the pointer to rest as a help tag does; the selected segment’s text is a second switch, Show Text of the Selection. Ruling changed 2026-11-11 (owner): this replaces, for hover and selection only, the 2026-09-27 rule in SelectionStyle that a selection uses the system accent and no custom colour; the region hues already broke it at rest (SelectionStyle.regionPalette). Acceptance: hovering line 3 of a purple region draws line 3 and the region’s box in purple, not blue; clicking it keeps both purple and stronger; with Show Text on Hover off no label appears; on, it appears after a short rest. Test: RegionHueSelectionTests.swift (the colours and the lit region), HoverReadoutTests.swift (the switches and the rest).
  • source.editor.split-has-a-door — [GAP] (#6413; owner 2026-11-08: easy tools to SPLIT segments. Code: segment.split and segment.unsplit exist in the engine (segments.py), the only door is ⏎ in the Reader’s text (source.textedit.return-splits-the-line)) Split is one more operation in the item table: Split… on a selected line or region opens the Split tool, the Editing bar’s tool that cuts where the person clicks on the shape (a line is cut at the x of the click into two lines in reading order, a region at the y into two regions; the cut is drawn before the click lands), ONE segment.split with one ⌘Z (segment.unsplit); Split at Cursor in the Reader’s text keeps ⏎’s meaning and is the same action; the engine computes the cut (SegmentSplitParams: at_offset for a text cursor, parts as reading spans for a point on the shape, the app sending the cut point in the segment’s own coordinates and the engine snapping it to the nearest word boundary of the counting reading), the FIRST part keeps the segment’s id, reading and provenance and the second is new with the words after the cut; a cut with no word boundary near it is refused in words; the chord is ⌥⌘S proposed, MenuShortcutUniquenessTests and the system-chord audit deciding (⌘S stays Save, ⇧⌘S Save As); the icon is scissors. Acceptance: select a line, ⌥⌘S, click a point on it: two lines in reading order with the text divided at the nearest word, one ⌘Z joins them back; Split… is in Edit › Segments ▸ and in the four context menus. Test: SplitDoorTests.swift (not yet written; the cut point to the engine’s split call for a line and a region, the item in every door, the chord declared once), the existing RegionSelectionTests.swift.
  • source.editor.two-bars-reader-and-editing — [GAP] (#6413; owner 2026-11-08: it is unclear what is the Reader bar and what is the Editing bar; there should be two. Code: three rows of chrome, the head controls (PreviewHeadControls.swift, with Edit Segments at line 125), the Reader toolbar with its Display menu (ReaderToolbar.swift, Edit Segments again at line 268, Edit image at +Controls.swift:276), and the markup tools row (PreviewMarkupToolsRow.swift, the Shape kind at line 370)) the Preview has TWO named bars and no third: the Reader bar (navigation: pages, renditions, up to the parent; zoom; the Display menu of what is shown) and the Editing bar (the image tools, the Shape tool with its kind, the Split tool, the markup tools and tags), the Editing bar shown when an editing tool is chosen or a segment is selected and hidden when reading, each bar labelled by its accessibility name; “Edit Segments” leaves both bars and both menus: the Shape tool on the Editing bar is Edit Shape (source.editor.no-mode-gate-selection-is-the-edit-state), and no toggle gates a verb. The existing controls move; none is rebuilt. Acceptance: a fresh page shows one bar, the Reader bar; selecting a segment shows the Editing bar under it with Edit Shape, Split and the markup tools; no control called Edit Segments exists; VoiceOver names “Reader bar” and “Editing bar”. Test: TwoBarsTests.swift (not yet written; which bar each control belongs to as a pure table; the Editing bar’s show rule from selection and tool state), the existing MenuShortcutUniquenessTests.swift for the chords the bars carry.
  • source.editor.run-the-next-step-on-this-selection — [GAP] (#6413; owner 2026-11-08: it is not always clear how to run a recipe on the next step from a selection or stage. Code: the run is folder-scoped only, Project › Read › Reading ▸ Run the Recipe on This Folder… and Run a Step Again on This Folder (FocusedRunRecipeOnFolderButton, RecipeSetupStore.redoSteps), the folder context menus, and Set Up’s stage page Run this step) one item, named from the recipe, “Run on This Page” or “… on These N Lines”, in Edit › Segments ▸, Project › Read › Reading ▸ and the context menu of every surface, where is the recipe’s first step not yet done for the selection’s page (the steps-done the folder row already reads, compute.recipe.folder-shows-steps-done), running through the selection-scoped start of menus.project.run-recipe-on-this-item (ui/menus-and-commands.md, the #4552 scope rule: exactly the selection, never the sidebar) with the step named as the one to run and the rest skipped as done; a Run Again ▸ submenu lists the steps already done for the page (the existing redo_steps); the chord is ⌥⌘⏎ proposed, the uniqueness test deciding; disabled with its reason when the selection has no page, the recipe has no undone step (“every step has run on this page”) or no project is open. Acceptance: with two lines selected after Find Lines, the item reads “Run Read on These 2 Lines” and starts a run whose Activity row names the page and the step; after Read it reads “Run Review on This Page”; with everything run it is disabled with its reason. Test: RunNextStepItemTests.swift (not yet written; the step name from steps-done, the label from kind and count, the disabled reason per state, the scope passed on), the existing PageMenuTests.swift.

  • source.editor.reader-uses-the-one-item-table — [GAP] (#6413; owner 2026-11-08: the Reader, its strip of line rows and its text, has no segment CRUD either. Code: ReaderLineRow’s context menu offers Correct This Line… and Delete only; the menu bar’s LineVerbsTarget (FocusedCommandButtons+LineVerbs.swift) offers Correct, Open, Delete Lines, Create Named Order; the text mode’s typing is readings with ⏎ split and ⌫ join (ReaderTextEdit); no Select All, New Line, Join, Split, attributes, Edit Shape, nudge or chord anywhere in Views/Reader/*) the Reader renders the SAME item table as every other door (source.editor.crud-one-action-each-every-door: SegmentMenuContent) on every line row’s context menu, on a region header row (the hierarchy of source.editor.hierarchy-selectable-with-verbs, a region’s lines grouped under it in Lines mode, the header selectable), on a selected run of text in text mode (the lines the run touches are the selection), and under Edit › Segments ▸ for the focused Reader selection; the Reader’s own verbs, Correct This Line… and Create Named Order, join that table as its last rows and keep their titles; LineVerbsTarget becomes the Reader’s adapter onto the one table and no second verb set remains. Select All Segments in the Reader is ⌘A, which selects every row (decision 3; the rule and its route are ui.select-all.focused-pane-and-its-meaning, specified once there); New Line adds a line after the selected row (in its region, in reading order) and opens it for text; Join on two rows is the one segment.merge; Split on a row opens the Split tool over the row’s picture (the cut at the click) and Split at Cursor in the text is the same action; Edit Shape on a row shows the handles over the row’s picture, or Reveal in Preview when the row is too small; Delete on any Reader surface, the row strip, Immersive, the multi-selection view, deletes the SEGMENT through SegmentDeleter (source.editor.delete-deletes-the-segment), never only a reading, and the attributes as everywhere; Run on These Lines as source.editor.run-the-next-step-on-this-selection; the chords are the table’s, with ⌫ deleting the selected ROWS when no text field has focus and the text’s character otherwise (the existing routing rule). Acceptance: right-clicking a line row in the Reader shows the same items, icons and chords as the Preview’s context menu plus Correct This Line… and Create Named Order; ⌘A selects every row; selecting two rows and ⌘J joins them with one ⌘Z; Split… on a row cuts it at the click into two rows; the region header row’s Delete asks as source.editor.deleting-a-parent-asks rules (decision 2) and then removes the region and its lines, or lifts them, in one batch. Test: ReaderUsesTheOneItemTableTests.swift (not yet written; the Reader’s context menu is SegmentMenuContent’s table plus the two Reader rows; the selection the text run maps to; ⌫ routing with and without a focused field), the existing RegionSelectionTests.swift.

  • ui.select-all.focused-pane-and-its-meaning — [GAP] (#6413; owner 2026-11-08: ⌘A selects all in the FOCUSED pane, the Reader, the document Inspector, the item list or the Preview; the sidebar never. Code: FocusedCommandButtons+SelectAll.swift (#4376) routes ⌘A by SelectAllRoutingPolicy over focusedPaneKind with librarySelectAll, inspectorSelectAll, previewSelectAll; the sidebar takes the chord and ignores it (ui.select-all.never-the-sidebar, #6364); text editing wins; the Reader has no route, so ⌘A falls through to the system’s text selection; no per-pane meaning of “all” is written) the window knows its last-focused pane and ⌘A means “all of THAT pane’s things”, pane by pane: the item list, every row in scope (library.chrome.select-all-follows-the-visible-surface); the document Inspector, every row of its list (the segments of the page in “Where it sits”); the Preview, every segment of the page (RegionSelection.selectAll); the Reader, every LINE of the page as the shared selection, not the text (decision 3: ⌘A itself, a new readerSelectAll route on the same policy; the Reader’s Lines and text modes are SwiftUI, ReaderLinesView and AnnotatableTextView, not a web view, so the route is ordinary focus; a focused text field in the Reader still gives ⌘A to the caret, the existing rule; the separate ⌥⌘A of the item table is dropped in the Reader); the sidebar, nothing, the chord taken and ignored, with a rename field’s caret the exception. Note on reader.select-all-selects-the-readers-text (ui/reader-view.md, #4376, GAP): the owner’s 2026-11-08 rule makes the Reader’s ⌘A select its lines; that bullet’s text meaning stays for a focused text field only and is not rewritten here. Acceptance: with the Reader focused ⌘A selects every line, lit in the Preview and listed in the Inspector; with the sidebar focused nothing is selected and the chord is not passed on; with the Inspector focused every row of its list. Test: SelectAllRoutingPolicyTests.swift (the existing test, extended with the Reader route and the per-pane meaning table; the sidebar case stays), the existing MenuShortcutBoundaryTests.swift.
  • sidebar.selection-never-spans-libraries — [GAP] (#6413; owner 2026-11-08: no multiple selection across projects or libraries in the sidebar; a ⇧- or ⌘-click into another project REPLACES the selection. Code: Views/Sidebar/State/CrossLibraryRoute.swift (#4995, #4996) routes ONE selection into another library, switch then route when it lands; SidebarView+SelectionRouting.libraryId(of:) resolves a destination’s library; no rule limits the multi-selection SET to one library) a sidebar selection belongs to ONE library: extending a selection (⇧ for a range, ⌘ to add, the #4377 conventions) with a row of another library REPLACES the selection with that row and routes it through CrossLibraryRoute as a single selection does; a range never spans libraries (the range stops at the library’s last row); a drag-select likewise. Acceptance: with two rows of project A selected, ⌘-clicking a row of project B leaves B’s row as the only selection and the window switches to B; ⇧-clicking from A’s row to B’s row selects A’s rows to the end of A only. Test: SidebarSelectionOneLibraryTests.swift (not yet written; the pure rule over CrossLibraryRoute and the selection set; the sidebar-refuses-Select-All case extended from SelectAllRoutingPolicyTests), the existing SelectAllRoutingPolicyTests.swift.
  • source.editor.labelled-shape-tools — [GAP] (#6413; owner 2026-11-08: adding a line, polygon or region in the Preview editor is unclear. Code: one Shape tool whose kind menu, shown only in Edit Segments, picks Box, Polygon or Baseline (PreviewMarkupToolsRow.swift, SegmentShapes.DrawKind, RegionInteractionLayer+DrawShape.swift), the gestures of source.editor.draw-shapes) the Editing bar (source.editor.two-bars-reader-and-editing) shows the shape tools as LABELLED buttons, each with its icon and a one-letter key while the bar has focus (never in a text field): Region (rectangle.dashed, R, drag a box: a REGION), Polygon (pentagon, P, click points, the first point or a double-click closes: a REGION by its outline), Line (underline, L, click points along the writing, double-click finishes: a LINE by its baseline), beside Paint (source.editor.paint-fits-a-shape), Split (source.editor.split-has-a-door) and Edit Shape; the kind menu goes; the tool chosen is remembered for the next gesture (source.editor.make-new-in-the-preview, #6183); the cursor is a crosshair and Escape cancels a drawing in progress (ShapeDrawingEscapeTests). Each finished drawing is the existing segment.create on the shown pass with one ⌘Z, exactly as source.editor.draw-shapes sends it today. Acceptance: the Editing bar reads Region · Polygon · Line · Paint · Split · Edit Shape with icons; pressing L and clicking four points along a line of writing makes a LINE with that baseline, selected, with handles; the next click-drag with Region chosen makes a region without choosing again. Test: LabelledShapeToolsTests.swift (not yet written; the tool table, the key map outside text fields, the remembered kind, the create call per tool), the existing ShapeDrawingEscapeTests.swift.
  • source.editor.paint-fits-a-shape — [GAP] (#6413; owner 2026-11-08: selecting text means clicking every point; wanted a PAINT tool, brush over the text and the app fits a polygon, region or line to the painted ink, with handles after) Paint is a brush: a stroke with a width, the width changed with [ and ] and shown as the cursor’s circle; on release the app sends ONE segment.create whose anchor is the STROKE (an anchor kind stroke with the points and the width, beside the existing box, polygon, baseline, point and path kinds; no new field and no new route), and the engine fits the stored shape at create time with the pure function that is the runner of the existing refine-shapes job kind (recipes/jobs.py:105, a job with no runner today; the same function later refines a model’s shapes), a function of the stroke and the page’s current image (the ink binarisation and connected components the engine already has in media/blank_page.py and media/flatten_curve.py): the ink components whose centre lies under the stroke are kept; a LINE gets the baseline as the ink’s smoothed lower envelope per column and an outline as the ink’s hull padded by half the brush width; a REGION gets the concave hull of the components (a box when Region is the kind); a stroke whose ink falls into two rows fits two LINES in one create batch, one audit row; no ink under the stroke refuses in words and makes nothing. The fitted segment is created on the shown pass, selected, with Edit Shape’s handles shown at once; one ⌘Z removes it; its making says “painted, fitted by Fichero” through the fields a segment already carries (provenance_kind = model-made, created_by = the fit’s name, models/__init__.py), until a person edits it. Acceptance: brushing once along a line of handwriting makes one LINE whose baseline follows the ink’s bottom and whose outline encloses it; brushing across a paragraph with Region chosen makes one region around its ink; brushing blank paper makes nothing and says “no writing under the brush”; dragging a handle afterwards is one segment.update. Test: test_paint_fits_a_shape.py (not yet written; synthetic ink: a straight line, a sloped line, two rows, a block, blank; the fit’s baseline, outline and refusal), PaintToolTests.swift (not yet written; the stroke to the create call, the width keys, the handles after).
  • source.editor.regions-nest — [GAP] (#6413; manager’s code facts 2026-11-08: segment.create takes parent_segment_id and segment.update re-parents; the engine’s only checks (segments.py around 1049–1080) are parent in the same pass and document and live; no rule on the parent’s KIND, no cycle check on a re-parent (merge alone has one), and a child of a deleted or merged parent is hidden, not deleted or lifted (segment_liveness_reason); the app’s SegmentShapes+Draw.swift sets a parent only for a baseline, so a drawn region never nests, and no re-parent gesture exists) regions NEST: a region may be the parent of a region (a column holding its paragraphs, a table its cells) and a line the child of a region that has no lines of its own, words under lines, as the ladder stroke › character › word › line › region › page says (“segment” is any level, decision 1); the engine states the allowed parent kinds in one table (a kind may parent its own kind or the next finer; a word never parents a line) and refuses the rest in words; a re-parent that would make a cycle is refused in words as merge’s already is; a drawn or painted segment inside an existing region of the page gets the SMALLEST containing region as its parent (the person overrides in the Inspector); re-parenting is a drag in the Inspector’s hierarchy and the Segments pane (one audited segment.update, one ⌘Z, the cycle and kind refusals said on the row). Acceptance: drawing a box inside a column region makes a region whose parent is the column and which the Segments pane lists under it; dragging a line from one region to another in the Inspector re-parents it with one ⌘Z; dragging a region onto its own child is refused with “a segment cannot be inside its own child”. Test: test_regions_nest_6413.py (not yet written; the kind table, the cycle refusal, the smallest-containing-region rule), HierarchyDragTests.swift (not yet written).
  • source.editor.deleting-a-parent-asks — [GAP] (#6413; today deleting a parent only HIDES its children, which stay stored and cannot be restored alone) deleting a segment that has children asks once, in the words of the item: Delete with Its N Children (one segment.delete batch over parent and children, one ⌘Z), Delete and Lift Its Children (the children re-parented to the parent’s own parent or the page in one segment.update_many, then the parent deleted, all one audit id and one ⌘Z), or Cancel; the hide-only behaviour is no longer a silent outcome; a parent with no children deletes without asking; a bulk delete over a mixed selection asks once for all. Acceptance: deleting a region of six lines offers the two ways; Lift leaves six lines under the page; one ⌘Z restores the region and re-parents them back. Test: test_deleting_a_parent_asks_6413.py (not yet written; both ways as one undo each), DeleteParentChoiceTests.swift (not yet written).
  • source.editor.orders.say-where-they-came-from — [PARTIAL] (first slice built 2026-11-11, not yet seen in the running app: the picker lists the working pass’s orders first and the other passes’ under From other passes, each titled with its pass (“Order: As in the File · from 0065.xml, Nov 7”; maker = its file, else its model, else its name), and with two passes the working pass’s Layout Order says “· shown on the page” (ReadingOrderChoice.sections, passLabel; from the passes the app already holds, so the engine’s list needs no pass_label). Test: ReadingOrderPassSectionsTests.swift. A Layout Order’s menu offers Delete This Order… (owner 2026-11-14: he looked for it there): a confirmation, then the pass it comes from goes through Info › Making’s own segment.pass_delete, undoable (ReadingOrderChoice.deletablePass, ReadingOrderPassSectionsTests.deleteThisOrder). Not built: the run and the step, the list head’s sentence, flows saying where they continue from; #6421; owner 2026-11-08: two layouts or reading orders after a run. Code: several orders per page is by design (source.order.named-multiple, reading_orders.py: named, authored, plural); each PASS gets its own as-written order and the working pass’s is listed first (#5450); the app’s picker (ReadingOrderPicker, #5160) shows names only; ReadingOrderRead already carries pass_id, kind, provenance_kind, created_by) every order says in words where it came from, on the picker and the list head: “as written by in , ” for a pass’s own order (from its pass’s step, model and run), “made by , ” for a named one, “flow” for a flow; the one list route (GET /api/reading-orders/document/{id}) carries the words as it carries the fields today, no second source. Acceptance: a page read by two finders shows two as-written orders, each naming its finder and run. Test: test_orders_say_where_from_6421.py (not yet written), the existing test_reading_orders.py and ReadingOrderStoreTests.swift. Note 2026-11-11 (owner: “Layout Order twice, often, in the Document Inspector, but the Preview can only show one, and it is not clear why”): the second is NOT a user-edited copy (a reorder edits the order in place, reading_order.place); it is another PASS’s own as-written order, listed because GET /api/reading-orders/document/{id} returns every pass’s, and titled identically because ReadingOrderChoice.title maps every as-written order that is not an import to the constant “Layout Order”. The Preview draws only the working pass’s box order (SegmentDisplay.geometry). So, besides the words above: the working pass’s orders come first and the one the Preview draws says so (“· shown on the page”); other passes’ orders sit under a “From other passes” heading in the picker; two orders never share a title. Owner evidence 2026-11-13 (screenshot): the Inspector’s Order tab menu listed “Layout Order” TWICE, beside “Document (flow)”, New Order…, New Flow… and Continue a Flow Here, with nothing to tell the two apart; so the title of every order carries its source and date (“Layout Order · Kraken, 13 Nov”, “Layout Order · Gemini, 12 Nov”, “Layout Order · Daniel’s, 11 Nov”) on every picker, and the default shown is one order (source.editor.orders.one-default-not-near-duplicates).
  • source.editor.orders.seen-on-the-page-three-ways — [GAP] (#6421; manager 2026-11-08: side by side, flip or overlay, the person chooses; reuse the Compare view modes, no second implementation) the Preview shows an order as NUMBERED overlays on the page (the entry’s position at each segment’s box, in the region’s hue, mapped onto the selected rendition as prep.preview-draws-segments-on-the-selected-rendition maps every box), and two orders are compared in the Compare view’s modes (CompareViewModel.Mode: Side by Side, Overlay, Wipe, and the one-at-a-time flip of source.try.compare-result-is-seen-large), the same component with orders as its two sides, one picker per side; the Reader’s Order list follows the order picked. Acceptance: choosing two orders in the Preview’s Show menu lays the page out twice side by side with the numbers; Overlay draws both sets of numbers in two hues; Flip alternates with →. Test: OrdersSeenOnThePageTests.swift (not yet written; the numbered overlay from an order and the mapped boxes; the two sides through CompareViewModel), the existing CompareViewTests.swift.
  • source.editor.orders.the-page-order-is-chosen-and-badged — [GAP] (#6421; today the working pass’s as-written is merely listed first; no badge, no statement of what it feeds; choosing the working pass is the existing audited pass.choose_working in content_representations.py, source.pass.working) ONE order is THE PAGE ORDER: the working pass’s as-written by default, or the order the person chooses, chosen as one audited action (setting the working pass for a pass’s as-written; a named order chosen as the page order is recorded on the page the same way, one field, one ⌘Z), badged “the page order” on the picker, the list head and the Preview’s overlay, every other order badged “from “; the page order is what the Reader reads, the export writes (page_export.py), neighbours answer (source.order.next-previous) and the next steps read, stated here as the rule and checked by the existing readers of the order. Acceptance: choosing the second finder’s order as the page order flips the badge, the Reader’s text re-orders, the export follows, one ⌘Z puts the first back. Test: test_page_order_feeds_reader_export_next_steps_6421.py (not yet written), the existing test_reading_orders.py.
  • source.editor.orders.a-secondary-order-can-be-deleted — [GAP] (#6421; manager 2026-11-08. Code: reading_order.delete exists, audited and undoable, a soft delete of one order whose entries stay and whose segments are untouched, with reading_order.restore; nothing guards the page order or the page’s only live order, and the app has no caller) Delete Order is a verb on the order picker (#5160), on an order’s row in the orders list and in its context menu, with the sentence before the press (“the segments stay; this order’s entries go with it; one ⌘Z brings it back”), ONE reading_order.delete, one ⌘Z; the engine refuses in words an order that is THE PAGE ORDER (source.editor.orders.the-page-order-is-chosen-and-badged: “this is the page order: choose another page order first”) or the page’s only live order (“the page needs one order”); the badge of the page order is what the guard reads. Acceptance: Delete Order on a second finder’s as-written order removes it from the picker, the Reader and the export unchanged; the same on the badged page order is refused with the sentence; one ⌘Z restores a deleted order with its entries. Test: the existing test_reading_orders.py extended (the two refusals; delete then restore), ReadingOrderStoreTests.swift.
  • source.editor.orders.combined-and-edited-on-the-page — [GAP] (#6421; no combine action exists; reading_order.create, .place, .remove, .restore_place, .renumber, .delete, .restore do) Combine Orders makes a NEW named order from two or more (the sources untouched): the rule, stated and shown before the press, is interleave by position on the page (each segment once, in the order of its first appearance walking both sequences by top-to-bottom, right-to-left or left-to-right as the page’s direction says) with “take A then B” as the other choice; one audited reading_order.create with its entries, one ⌘Z; and an order is edited on the Preview’s numbered overlays: drag a number to another place (reading_order.place), renumber from a clicked segment (reading_order.renumber), and the segment verbs of the one item table (join, split, delete) on a numbered box act on the segments as everywhere, the order following. Acceptance: Combine on two as-written orders of 40 and 42 entries makes “Combined of A and B” with every segment once in page order, A and B unchanged; dragging number 7 before 3 on the overlay re-places it with one ⌘Z. Test: test_combine_orders_6421.py (not yet written; the interleave and the take-then rules; sources untouched; one undo), OrderOverlayEditTests.swift (not yet written). Owner 2026-11-13 (#6421, section H of the UX requests): a page ends up with several layout orders (Kraken’s, a model’s, a person’s Layout Order); the person combines two OR MORE into one, the result NAMED by the person (default “Combined of A, B and C”) and CHOSEN as the page order in the same act, one audit set (reading_order.create with its entries, then the page-order choice of source.editor.orders.the-page-order-is-chosen-and-badged) undone by one ⌘Z, as Group is (source.editor.group-makes-a-parent-from-the-selection); the sources stay and fold under the new order, hidden from the picker’s first section, and the one undo restores them beside it (ruling 17; source.editor.orders.one-default-not-near-duplicates). Storage today: one row per order (readingorders: pass_id, name, kind, provenance_kind, certainty, deleted_at) and one entry per segment with a fractional position; an order holds one pass’s segments and only a flow crosses that line, so Combine over orders of DIFFERENT passes (Kraken’s lines on Kraken’s pass, a model’s on its own) is refused with both passes named, the refusal offering to compose a pass first (source.pass.compose-from-layers, #5232; ruling 11, ui/panes-workspaces.md H), and the default rule is interleave with take-then as the other choice (ruling 12). Combine is offered from the one order control (source.editor.orders.one-control-on-every-surface) whenever the page has two or more orders that are not the same.
  • source.editor.orders.one-default-not-near-duplicates — [GAP] (#6421, #6576; owner 2026-11-13) engine and app. A page shows ONE order by default, the page order (source.editor.orders.the-page-order-is-chosen-and-badged; a combined order once made), and the picker’s first section lists it alone; every other order sits under Other orders, titled by its source and date (source.editor.orders.say-where-they-came-from). Two orders over the same segments whose sequences are the same, or differ only by segments one of them lacks, are near-duplicates: the engine marks the later one same_as: <order_id> in the list answer (GET /api/reading-orders/document/{id}, worked out when asked, never stored) and the picker folds it under the first as “same as “, so a page read by Kraken, then a model, then ordered by hand reads as one order and its variants, never a list of look-alikes. <em>Built:</em> nothing; today the working pass’s as-written is first and the rest are grouped by pass (<code>ReadingOrderChoice.sections</code>). <em>Tests:</em> <code>test_orders_same_as.py</code> (to write: equal sequences; a subset; a different sequence is not the same), <code>ReadingOrderPickerDefaultTests</code> (to write: one order in the first section; near-duplicates folded under it).</li> <li><code>source.editor.orders.one-control-on-every-surface</code> — <strong>[GAP]</strong> (#6576, #6482; owner evidence 2026-11-13: only the Inspector’s Order tab and the Segments list head had “Layout Order ▾”; the Source pane, the segment list’s other lenses and the Reader’s Content gave no way to choose) app. ONE order control (<code>ReadingOrderPicker</code>, <code>source.editor.layout-order-is-plainly-labelled</code>) is on every surface that reads an order: the Source pane’s bar (its Options, <code>panes.bar.one-filter-and-options-component</code>), the Segments pane’s head in every lens, the Reader’s bar (<code>reader.order.switchable</code>) and the Inspector’s Order tab; each shows the order it follows by title, and the picker on any of them lists the same orders in the same sections with the same titles. The choice is the pane’s (<code>source.panes.choice-is-remembered-per-pane</code>); choosing the page order is the Order tab’s audited action and badges on all of them. <em>Tests:</em> <code>OrderControlEverywhereTests</code> (to write: the four surfaces mount the one picker; the same sections from one store; a pane’s pick is its own).</li> <li><code>source.editor.segments-follow-the-page-change-event</code> — <strong>[GAP]</strong> (#6574, #6423; owner 2026-11-13, and the screenshot of a list head saying “No Reading Order” beside nine numbered Kraken lines drawn on the page) app and engine. The Segments list, the Inspector’s Order tab and the boxes drawn on the page read the SAME working lines in the SAME order (one <code>SegmentStore</code> read of the working pass, one <code>ReadingOrderStore</code> of the page order) and all three refresh when the page’s change event arrives (<code>segment.*</code>, <code>pass.*</code>, <code>reading_order.*</code> on that page, the stream <code>SegmentChangeObserver</code> already watches), never only on clicking away and back: a Kraken run from a workflow landing its pass re-draws the lines, re-lists them and re-reads the Order tab within the event; a pass that lands EMPTY keeps the older pass’s lines drawn and listed and the list head says the new pass found none (ruling 15, <code>ui/panes-workspaces.md</code> H); and “No Reading Order” is never shown beside drawn numbered lines, because the list reads the order the overlay numbers, and a page with lines and no named order lists them as written (<code>ReadingOrderList</code>’s unordered branch, #5204). Today the list goes stale after a run (#6574): <code>ReadingOrderStore.loadFollowing</code> re-reads only when the working pass id changes, and the overlay reads its own cached pass. <em>Tests:</em> <code>SegmentsFollowThePageTests</code> (to write: one event, three surfaces re-read; an empty pass keeps the older lines and names itself; the empty state and the overlay never disagree), <code>test_a_runs_pass_raises_the_page_event.py</code> (to write: the engine sends the page’s event when a run’s pass is made).</li> <li><code>source.editor.drawing-a-region-always-makes-it</code> — <strong>[GAP]</strong> (#6580; owner 2026-11-13) app and engine. Drawing a region on the page makes the region as soon as the shape closes, as one audited <code>segment.create</code> with one ⌘Z; the name is optional: the name field opens after the region exists, and Esc or clicking away leaves it unnamed (its kind icon and number stand for it, <code>source.editor.kind-has-its-own-icon</code>); a name typed later is one <code>segment.update</code>. A region is never lost for want of a name (ruling 14, <code>ui/panes-workspaces.md</code> H). <em>Tests:</em> <code>RegionDrawTests</code> (to write: the create is sent on close with no name; naming after is an update; Esc keeps the region).</li> <li><code>source.editor.pass-shown-is-picked</code> — <strong>[PARTIAL]</strong> (#6670; owner 2026-11-17: after a Kraken run the Inspector listed three Layout Orders and the Source showed none of the run’s segments; the only way to switch was to promote one in Artifacts) the Source’s head and the Reader’s head each carry a <strong>Pass</strong> menu, labelled with the pass shown (owner 2026-11-17: an icon alone was missed), when the page has two or more passes: every pass, titled as the order picker titles it (<code>ReadingOrderChoice.passLabel</code>: maker, date), the working pass first and marked “promoted” (or “default” while nobody chose), a checkmark on the one shown. Picking one shows its segments at once on the Preview, the Segments and Order lists and the Reader’s Lines, without promoting it; the choice is per page and lasts while the app runs; promoting (<code>pass.choose_working</code>) stays the way to set the default, and the menu’s “Show the Promoted Pass” returns to it. Why the run’s segments were not shown: the app showed only the engine’s ranked head (<code>rank_passes</code>): a chosen pass, then any pass a person touched, then a file’s text layer, then the newest machine pass, and an unconverted result beside a real pass is passed over; so a Kraken pass on a page someone had edited (or a PDF) is listed and never drawn. <em>Built:</em> <code>SegmentStore.pickPass</code> / <code>shownPass</code>, <code>workingSegments</code> reads the shown pass, <code>SegmentDisplay.drawingOrder</code> puts it first, <code>PassPickerMenu</code> in both heads. <em>Not built:</em> the Reader’s transcript text is the engine’s page text, which is the working pass’s; it follows the picked pass only in Lines. <em>Test:</em> <code>fichero/Tests/Unit/general/Models/PassShownIsPickedTests.swift</code>.</li> <li><code>source.editor.orders.a-flow-is-made-and-followed-across-pages</code> — <strong>[GAP]</strong> (#6421; owner 2026-11-11: “Flow I’ve not tested, make sure we can do it.” Code: the engine’s <code>flow</code> kind is the one order that may cross pages (<code>reading_order.place</code> skips the pass check for a flow), with <code>flows_continuing_onto</code> and <code>GET /api/reading-orders/flows/onto/{document_id}</code> and the neighbours route; the picker offers New Flow… (<code>ReadingOrderPicker</code>, an audited <code>reading_order.create</code>); never yet tried in the running app) a person makes a flow from the picker on one page, adds a region or line from the next page to it, and steps Next and Previous along it from either page; the second page’s picker lists the flow as continuing onto it; the Order list shows its entries from both pages, each labelled with its page; ⌘Z undoes the make and each add. Acceptance: on page 1 New Flow… “Letter”, add region 2 of page 1 and region 1 of page 2, Next from page 1’s region lands on page 2’s, page 2’s picker shows “Letter (flow)”, ⌘Z three times leaves no flow. <em>Test:</em> the existing <code>test_flows_that_could_continue_onto_a_page.py</code> and <code>ImportedPageDrawsItsBoxesTests</code> flow cases; <code>ReadingOrderFlowTests.swift</code> (not yet written) after the run in the app names what breaks.</li> <li><code>source.editor.select-takes-you-there-and-back</code> — <strong>[GAP]</strong> (#6413; owner 2026-11-08. Code: ONE reveal exists, <code>InspectorPath.reveal(segmentIds:into:documentId:store:)</code> behind <code>WindowState.revealSegments</code>, selecting in the shared <code>RegionSelection</code> and writing <code>revealRect</code> and <code>revealCount</code> so the owning Preview scrolls and zooms (#5424); its callers are the Reader’s line click, the Order list’s DOUBLE-click, the knowledge graph’s source click and the Shortcuts intent; a single click in the Segments pane or an Inspector row does not reveal, the other panes do not scroll their own row, and no Back exists) selecting a segment anywhere, a single click in the Segments pane, the Inspector’s hierarchy rows or the Reader, calls the ONE reveal, so the Preview scrolls and zooms to it and EVERY pane scrolls its own row into view on <code>revealCount</code> (the Segments pane, the Inspector, the Reader’s Lines mode); and the jump can be undone: Back returns the Preview’s zoom and every pane’s scroll to where they were before the reveal, Forward redoes it, as entries on the WINDOW’S EXISTING navigation history (<code>AppNavigationHistory</code>, <code>NavigationHistoryManager</code>, the Library’s Back and Forward items and chords), never a second stack; a reveal pushes one entry with the previous view state and the previous selection; ⌘[ and ⌘] are those items’ (focus-scoped beside the Set Up pager’s, the uniqueness test deciding). Acceptance: clicking a line in the Segments pane zooms the Preview to it, scrolls the Inspector to it and lights it in the Reader; Back restores the earlier zoom and selection; Forward returns. <em>Test:</em> <code>RevealAndBackTests.swift</code> (not yet written; every surface’s click reaches the one reveal; each pane’s scroll on <code>revealCount</code>; the history entry’s state and its Back through the real navigation history), the existing <code>ContentViewRestoredSelectionTests.swift</code>.</li> <li><code>source.editor.group-makes-a-parent-from-the-selection</code> — <strong>[GAP]</strong> (#6413; owner 2026-11-08: Group Into Region and Make Line from Words, the inverse of Split. Code: <code>segment.merge</code> joins INTO a survivor and makes no parent; <code>segment.update_many</code> is attribute-only by design (kind, furniture, cascade facts; not shape, not parent); <code>segment.update</code> re-parents ONE segment; <code>segment.create_many</code> creates N; so a group today is N+1 actions and N+1 undos. Manager 2026-11-08: no new action) <strong>Group / Make New From Selection</strong> takes two or more selected segments of one level (words, lines or regions, same pass) and makes a NEW parent of the next coarser kind (words → a line, lines → a region, regions → a region; <code>source.editor.regions-nest</code>’s kind table decides and refuses the rest in words) whose shape is the union of the children’s boxes and outlines (the hull), re-parenting the originals as its children in their page order, as ONE audit SET undone whole: <code>segment.create</code> for the parent and <code>segment.update_many</code> gaining <code>parent_segment_id</code> (a parent is not an anchor, so the attribute-only rule stands; the same cycle and same-pass checks as a single re-parent), the app sending the two and holding their audit ids as one ⌘Z step through the engine’s set undo (<code>POST /api/actions/audit/undo</code> with <code>audit_ids</code>, <code>safety.undo.a-set-is-undone-whole</code>); <strong>Ungroup</strong> is the reverse, <code>source.editor.deleting-a-parent-asks</code>’ lift: <code>segment.update_many</code> lifting the children to the parent’s parent, then <code>segment.delete</code> of the parent, the same set undo. Both are items of the one table on every door (Edit › Segments ▸, every context menu, the Inspector’s hierarchy) with one icon each (<code>rectangle.3.group</code> Group, <code>rectangle.3.group.bubble</code> Ungroup) and chords proposed for the uniqueness test (⌥⌘G Group, ⌥⇧⌘G Ungroup; ⌘G is Find Next); Group is disabled with its reason for a mixed-level or cross-pass selection or fewer than two. Acceptance: select four words of a line that has none and Group: one new line holding them, listed once under its region, one ⌘Z removes the line and frees the words; select three lines and Group: a region around them with the three as its children; Ungroup on it lifts the three and removes it with one ⌘Z. <em>Test:</em> <code>test_group_is_one_audit_set_6413.py</code> (not yet written; the two actions’ rows undone whole; the kind table’s refusals; the hull), <code>GroupUngroupTests.swift</code> (not yet written; the item’s enabled rule, the two calls, the set held as one undo step).</li> <li><code>source.editor.levels-section-and-working-text</code> — <strong>[GAP]</strong> (#6429; owner 2026-11-08, decision 5; the Fable look is <code>agent-work/status/briefs/readings-levels-look-2026-11-08.md</code>. Code: five fixed levels plus translation with the choice and the counting worked out per kind AND level (<code>source.reading.counts-per-level</code>, <code>segment_readings.counting_by_kind_and_level</code>), readings carrying <code>level</code>, <code>created_by</code>, <code>read_from</code> and their run; the Normalise step runs once per level asked (<code>source.recipe.into-what-is-a-multi-select</code>, <code>start.LEVEL_PROMPTS</code>, <code>run_titles</code>); the Inspector’s Text section lists a segment’s readings flat with Make This Count and Edit… (<code>InspectorReadingEditor</code>, <code>representation.create</code>); no level grouping, no level switch in the Reader or Preview, no statement of what a step reads or writes) the segment Inspector (and the page level of its path) has a <strong>Levels</strong> section: one row per level in the fixed order (As written, Expanded, Regularised, Modernised, Graphemic, Translation <tag>) built from the readings the segment has, each row showing the COUNTING reading’s text at that level in the segment’s direction and, under it, who made it (“by <model> in <run>, <when>“, “by <person>“, “corrected by <person>“); two badges, <strong>Shown</strong> on the level the window shows and <strong>Working text</strong> on the level the next steps read; the verbs on a row: Show This Level, Make This Count (the existing choice when the level has several readings), Edit… (the existing editor, the correction a new reading at THIS level), Compare Levels…, and <strong>Use as Working Text</strong>; a level the segment lacks is a quiet row with <strong>Make <level>…</strong>, which runs the existing Normalise step for that level on this page or these N lines through the selection-scoped start (<code>ui/menus-and-commands.md</code> Step 1.1), priced first when the model is in the cloud, or Type a Reading… at that level. <strong>The working text</strong> is <code>as_written</code> by DEFAULT and the person can change it, per page or for the project (the page’s choice winning), as one audited setting with one ⌘Z, read by every later step (Names, Dates, Statements, normalisation of a further level, export and the page’s constructed text, <code>source.model.page-text-is-constructed-from-the-segments</code>) in place of as_written; the Working text badge and the step lines say which. Acceptance: a line with as_written, modernised and a translation shows three rows with their makers; Use as Working Text on Modernised moves the badge, and the next Names run on the page reads the modernised text (its row says so); Make Expanded… on a page without it runs the Normalise step for that level on that page alone. <em>Test:</em> <code>InspectorLevelsTests.swift</code> (not yet written; the rows from a readings list, the badges, the verbs’ calls), <code>test_working_text_is_read_by_later_steps_6429.py</code> (not yet written; the default, the page’s choice winning, the step reading it), the existing <code>test_reading_levels.py</code>.</li> <li><code>source.editor.levels-shown-side-by-side-and-switched</code> — <strong>[GAP]</strong> (#6429; owner decision 5) the levels are SEEN SIDE BY SIDE, working text | normalised or modernised | translation, in the Compare component (<code>CompareViewModel</code>: Side by Side, Overlay, Wipe and Flip) with LEVELS as its sides for the page or the selection, line by line, differing words marked as readers’ disagreement is marked, opened from the Inspector row’s Compare Levels…, from Edit › Segments ▸ and from the Reader bar; the compare answer chooses its sides by level where it chooses readers today (<code>GET /api/documents/{page_id}/compare-readers</code> gains <code>levels=a,b</code>; the one contract addition, named); and ONE shared <code>shownLevel</code> per window drives the Reader’s text, its Lines mode and the Preview’s inline text, falling back to the working text where a segment lacks the level and marking the fallback faintly, never blank; the switch is a menu on the Reader bar and View › Reading Level ▸, with chords PROPOSED for the uniqueness test: ⌥⌘↑ / ⌥⌘↓ step the shown level, ⌥⇧⌘W Use as Working Text, ⌥⌘L Compare Levels… (⌥⌘L is the loupe today: the test decides and the loser moves). Acceptance: switching the shown level to Modernised re-reads the Reader and the Preview’s inline text; Compare Levels on a page lays working text and translation side by side with the differing words marked; the Inspector’s Shown badge follows. <em>Test:</em> <code>ShownLevelTests.swift</code> (not yet written; the shared state, the fallback mark, the menu and chords), the existing <code>CompareViewTests.swift</code> and <code>test_compare_readers_5900.py</code> extended for the level sides.</li> <li><code>source.editor.mark-a-stretch-unclear-from-the-reader</code> — <strong>[GAP]</strong> (#6451, the owner’s second paragraph of 2026-11-08 21:19, its own issue to open; Code: the engine’s <code>editorial.record</code> takes <code>segment_id</code>, <code>kind</code> (unclear, lost, restored, supplied, superfluous, deleted, added), <code>representation_id</code>, <code>char_start</code> / <code>char_end</code> in code points of that reading, <code>reason</code>, <code>place</code>, <code>certainty</code>, is audited and undoable with <code>editorial.withdraw</code> as its inverse (<code>api/routes/document/editorial.py</code>; <code>source.sure.editorial-facts</code>), and the facts are drawn as the editor’s signs where the reading is shown; the ONLY app door is Inspector › Certainty and Damage › Mark (<code>InspectorEditorialSection</code>, <code>InspectorEditorial.record</code>), which spans the WHOLE counting reading, <code>charStart</code> 0 to its end; the Reader’s Lines row (<code>ReaderLineRow</code>, <code>ReaderLineEditor.reading</code>) and Content lens show the counting reading and publish their text selection as UTF-16 offsets on <code>.readerTextSelection</code> (<code>postReaderSelection</code>), and the page text’s line map (<code>page_text_cache.line_map</code>) gives each line’s span) a person marks a STRETCH of a line from the Reader: select a word or more in a Lines row or in the Content lens and choose <strong>Edit › Mark ▸ Unclear</strong> (also <strong>Lost</strong> and <strong>Supplied</strong>, cheap because the action and the signs exist: Lost is a position with no span, the engine’s <code>position_only</code> rule, placed at the selection’s start; Supplied spans the selection), from the menu bar, the Reader’s context menu or the chord; the app sends <code>editorial.record</code> with the line’s segment id, the counting reading’s id and the selection converted to that reading’s code points (the Content lens through the line map to the line, then to code points; a selection across two lines makes one fact per line in one audit set, as Step 1.16 batches), the same request the Inspector sends with a span instead of the whole; one ⌘Z withdraws it (<code>editorial.withdraw</code>, the existing inverse), <strong>Withdraw Mark</strong> on a marked stretch’s context menu does the same by hand; the mark is DRAWN on the stretch wherever that reading is shown, the Reader’s rows, the Preview’s inline text (<code>OCRGeometryOverlay</code>) and the Inspector’s Text section, as the editor’s signs already drawn, and the Certainty and Damage section lists it with its extent as “letters a–b” (the words it has). No new action or route. The chord: <strong>⇧⌘U Mark Unclear</strong> PROPOSED for <code>MenuShortcutUniquenessTests</code> (⌘U is Underline, a standard chord, untouched; ⌥⌘U is the Editing bar’s Select Text tool, <code>PreviewMarkupToolsRow</code>; ⇧⌘U is in neither section 4’s complete list nor the sources; the ⇧ variant of the mnemonic key is the audit’s pattern), Lost and Supplied menu only; one row in the command table, Edit › Mark ▸ (Unclear, Lost, Supplied, Withdraw Mark), surfaces R, I, P (the inline text), icon <code>questionmark.square.dashed</code>. Acceptance: selecting “Cucharas” in a Lines row and pressing ⇧⌘U records one unclear fact spanning those code points, drawn in the row, the Preview’s inline text and the Inspector, listed as “letters 1–8”; ⌘Z withdraws it everywhere; a selection across two lines makes two facts under one undo; the Inspector’s whole-segment Mark is unchanged. <em>Test:</em> <code>ReaderMarkUnclearTests.swift</code> (not yet written; the selection to code points per line, the one request per line in one set, the three kinds’ spans, the chord through the uniqueness test), <code>test_editorial_record_a_stretch_6451.py</code> (not yet written; a span inside the reading accepted, out of range refused in words, withdraw as the undo), the existing <code>test_editorial_facts.py</code> and <code>MenuShortcutUniquenessTests.swift</code>. <em>Spec change:</em> 2026-11-08 21:25, the owner’s three amendments; <code>source.sure.editorial-facts</code> untouched.</li> <li><code>source.editor.mark-a-stretch-first-slice</code> — <strong>[PARTIAL]</strong> (#6454; first slice of Step 1.19, the build of <code>source.editor.mark-a-stretch-unclear-from-the-reader</code>, whose text stays as written; pinned by the existing <code>fichero-server/tests/unit/api/test_editorial_facts.py</code> (a span inside the reading, one past the end refused, ⌘Z withdraws) and <code>fichero/Tests/Unit/general/Models/ReaderMarkTests.swift</code>) the engine takes a span for Unclear, Lost and Supplied; <code>ReaderMark.requests</code> turns a selection over the shown lines into one <code>editorial.record</code> request per line, in code points, on the reading shown for that line. NOT built: Edit › Mark ▸ with ⇧⌘U (a menu item nothing publishes a selection to is permanently disabled, which <code>test_every_declared_focused_value_is_published</code> forbids, so it waits for the Reader surface that carries the selection: the Lines rows are SwiftUI Text with no selection range), sending the requests as one audit set, the signs drawn in the Lines row and the Preview’s inline text, and Withdraw Mark.</li> <li><code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code> — <strong>[GAP]</strong> (#6451; the owner’s question 2026-11-08: when a line’s text is shown in the source pane, how is the reading chosen? <strong>The rule today, read from the code</strong> (<code>models/readings.py</code> <code>resolve_counting</code>, pure; <code>segment_readings.counting_readings</code>; <code>source.reading.chosen-is-worked-out</code>, <code>source.reading.chosen-follows-project-rule</code>, <code>source.reading.counts-per-level</code>): every surface shows the COUNTING reading of kind transcription at the working text’s level (<code>counting_level</code>: the reading’s own level, else as written): (1) a LIVE person’s choice (<code>ReadingChoice</code>, newest first, skipped when it names a retracted or absent reading) wins in any project; (2) else a person’s correction retires the reading it corrects (<code>derived_from_representation_id</code>, #5175); (3) else in a RELAXED project the newest person’s reading, else the best machine’s (<code>_best_machines_first</code>: a checked one, then the reader that measured better on this project, then the newest; the date only breaks ties), labelled “not yet checked”; in a STRICT project one person’s reading counts, SEVERAL people’s readings make NONE count (<code>source.reading.equal-alternatives</code>), and machines alone give the best machine’s, labelled. The Preview’s inline text (the source pane; the segment list’s <code>text</code>, filled per batch by <code>counting_readings</code>), the Reader’s Lines row (<code>ReaderLineEditor.reading</code>) and the Inspector’s Text section (<code>InspectorText.Counting</code>, its basis words) all read that one answer; the ONE divergence: the Lines row falls back to the segment’s stored <code>text</code> when nothing counts (<code>shownWords</code>), so a strict project with two people’s readings shows an unlabelled text there and nothing in the Preview; and only the Inspector SAYS the basis, the Preview and the Reader show bare words) the shown reading is ALWAYS the counting answer, VISIBLY LABELLED, with a SWITCHER on the line: wherever a line’s text is shown, the Preview’s inline text, the Reader’s Lines row, the Content lens’s line and the Compare and disagreement views’ line heads, the line carries ONE small label (the text budget of <code>ui/menus-and-commands.md</code> <code>menus.less-text-more-indicator</code>): “<reader or person> · <level>” and a basis glyph (a check for chosen, a person glyph for a person’s reading or correction, a hollow circle for a machine’s not yet checked, a dash for none counts), the basis words in the tooltip and accessibility label as <code>InspectorText.Counting</code> has them; the label is a <strong>menu</strong>, the switcher: every reading of the line grouped by level in the fixed order, the counting one checked, each row “<reader or person> · <level> · <when>“, a pick calling <code>reading.choose</code> for THIS segment with <code>expected_counting_id</code> (<code>source.compare.pick</code>; a person only; one ⌘Z; 409 re-reads), the same rows and verb as the Inspector’s Text section, the Levels section (Step 1.17) and the popover of <code>source.disagree.popover-lists-every-reader-and-the-lines-other-readings</code>, ONE row model for the four; the Lines row’s fallback to the stored <code>text</code> goes: when nothing counts the row shows the newest person’s reading with the dash glyph and the label “N readings, none chosen” and the switcher offers them (DECIDED by the owner 2026-11-08 21:50: the newest person’s reading, so labelled; never a blank line, never an unlabelled text). Acceptance: a line read by Kraken and corrected by a person shows the correction with the person glyph and “<person> · as written”; the switcher on it lists Kraken’s and the correction, picking Kraken’s moves the check and the Preview’s inline text, the Reader row and the Inspector change together, ⌘Z moves it back; in a strict project with two people’s readings the row shows the newer with the dash and “2 readings, none chosen”, never the stored text. <em>Test:</em> <code>ShownReadingLabelTests.swift</code> (not yet written; the label and glyph per basis from the counting answer, the switcher’s rows from the readings list, the pick’s call, the fallback gone), <code>test_shown_text_is_the_counting_answer_6451.py</code> (not yet written; the segment list’s text equals the counting answer per rule, none-counts gives no text and the newest person’s id for the label), the existing <code>test_counting_and_working_pass.py</code> and <code>test_reading_levels.py</code>. <em>Spec change:</em> 2026-11-08 21:25; <code>source.reading.chosen-is-worked-out</code> and <code>source.reading.chosen-follows-project-rule</code> untouched, restated here as the rule the surfaces obey. <em>Note 2026-11-11 (owner: the Inspector’s segment pane says “Text”, then “Transcription”; “it could be reading, no? these aren’t renditions”):</em> the section is headed <strong>Readings</strong>, the engine’s and these specs’ word; each group under it is headed by the reading’s kind (Transcription, Translation, …). A rendition is a picture of the page, never a reading.</li> <li><code>source.editor.live-link-from-the-reader-to-the-source-pane</code> — <strong>[GAP]</strong> (#6451; manager for the owner 2026-11-08 21:30; Code: the Reader already PUBLISHES its text selection on the <code>.readerTextSelection</code> seam (<code>postReaderSelection</code>, <code>ReaderPreviewLinking.swift</code>: document id, UTF-16 offsets into the displayed transcript, the selected text) and the Preview CONSUMES it to light the word boxes whose spans intersect (<code>wordBoxes(intersecting:)</code>, <code>OCRGeometryOverlay</code>); a pane’s region selection is published to the window as the focused <code>RegionSelection</code> (<code>WindowState.focusedRegionSelection</code>), consumed by the Inspector, the Reader’s Lines view and the artifact panel; the disagreement lens keeps its selected word PRIVATE in <code>ReadingDisagreementStore.selected</code> and publishes nothing; no mechanism joins a word to the reading it came from) clicking a word in the Reader, in a Lines row, the Content lens or the disagreement and compare lenses, shows LIVE in the source pane (the Preview) WHERE it is and WHICH READING it comes from: the Reader pane is the PUBLISHER, through the two existing seams and no new one: it posts the selection on <code>.readerTextSelection</code> (the lenses that do not post today, the disagreement and compare lenses and the Lines row, post as the Content lens does, the word’s span in the line’s counting reading mapped to the page text through the line map) and sets the window’s focused <code>RegionSelection</code> to the line segment, and the word segment where the page has one; the Preview and the Inspector are the CONSUMERS: the Preview lights the word’s box as it does for a drag and, new, pins the shown-reading label of <code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code> at the lit line, “<reader or person> · <level>” with the basis glyph, and when the click came from a compared reader’s variant in the popover the label names THAT reader and its reading with a “not counting” dash until Make This Count makes it count; the Inspector follows the segment as it follows any focused selection; moving the click moves the box and the label, clearing the selection clears them, no extra step, no mode. Acceptance: clicking “Cucharas” in the disagreement lens lights its box in the Preview with “Gemini 3.1 Pro · as written ✓”; clicking the next word moves box and label; clicking the Haiku row in the popover relabels the box “Claude Haiku · as written —” and Make This Count turns the dash into the check; the Inspector shows the line. <em>Test:</em> <code>ReaderToSourceLiveLinkTests.swift</code> (not yet written; each lens posts on the seam and sets the focused selection, the label follows the posted reading, clearing clears), the existing <code>ReaderPreviewLinkingTests.swift</code> and <code>DisagreementWiringTests.swift</code>. <em>Spec change:</em> 2026-11-08 21:30; the two seams are the existing ones, nothing new.</li> <li><code>source.editor.segment-row-carries-the-shown-reading-facts</code> — <strong>[PARTIAL]</strong> (#6455, Step 1.20 engine slice; a note on <code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code>, whose acceptance is untouched; pinned by <code>fichero-server/tests/unit/api/test_shown_text_is_the_counting_answer_6451.py</code>) each segment list row (<code>SegmentRead</code>) carries <code>counting_basis</code> (why its <code>text</code> counts, or <code>none</code>), <code>counting_level</code> and <code>read_by</code> (the reader’s model, else the person), worked out by <code>counting_answers</code> from the SAME answer the page text uses, so the label needs no second request; where NONE counts the row names the newest person’s reading (else the newest) with basis <code>none</code> and its <code>text</code> is left as it was, not claimed. The Swift label, switcher and live link are not yet built. <em>Spec change:</em> 2026-11-09, new bullet only. <em>Built 2026-11-09:</em> the Reader’s Lines row draws the label (<code>ShownReadingLabel</code>, from the line’s readings; where none counts it shows the newest person’s reading with the dash and “N readings, none chosen”, no longer the stored text; pinned by <code>ShownReadingLabelTests.swift</code>). <em>Not built:</em> the Preview, Content and compare surfaces, the switcher and the live link.</li> <li><code>source.editor.pane-title-says-what-is-showing</code> — <strong>[PARTIAL]</strong> (#6458; owner 2026-11-08 22:05: the pane title menu shows only the lens name. Code: the pane head is <code>[✕ · kind ▾ lens ▾] [breadcrumb] [controls]</code> (<code>PaneHead</code>), the lens control’s title is the lens’s fixed word (<code>ReaderLens.title</code>: “Content”, “Lines”, “Where the Readers Disagree”), the crumbs already shorten through <code>ViewThatFits</code> and middle truncation) the Reader’s lens ▾ title SAYS WHAT IS SHOWING when there is room and shortens to the lens name when there is not: three forms chosen by <code>ViewThatFits</code> as the crumbs are, the longest that fits: <strong>full</strong> “Content · Claude Sonnet · as written ✓” (the lens name; the page’s shown reading summarised from the one row model of <code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code>: the reader or person when every line’s counting reading has the same maker, else “3 readers”; the shown level, <code>shownLevel</code> of <code>source.editor.levels-shown-side-by-side-and-switched</code>, else the working text’s level; the basis glyph, a check when a person chose or wrote, a hollow circle when a machine’s not yet checked, a dash when none counts), <strong>middle</strong> “Content · Claude Sonnet”, <strong>short</strong> “Content”; the Lines lens the same; the disagreement lens “Where the Readers Disagree · 3 readers · 82 %” shortening to “3 readers · 82 %” then the lens name; the full form is always the tooltip and the accessibility label; the text budget of <code>ui/menus-and-commands.md</code> <code>menus.less-text-more-indicator</code> holds (no sentence, the glyph says the basis). Acceptance: a wide Reader on a page read by Claude Sonnet and corrected on two lines reads “Content · 2 readers · as written ✓”; narrowed, it reads “Content · 2 readers” then “Content”; with Modernised shown it reads “· modernised”; the tooltip is the full form at every width. <em>Test:</em> <code>PaneTitleSaysWhatIsShowingTests.swift</code> (written, not yet run: the three forms, the basis symbol, the tooltip; the per-line summary rule is not built in the Reader, so no test covers it yet), the existing <code>PaneHeadTests.swift</code> if present else <code>ReaderToolbarTests.swift</code>. <em>Spec change:</em> 2026-11-08 22:10, the owner’s #6458, spec first then code. <strong>Built:</strong> <code>PaneTitleForms</code> (three forms, the basis as an SF Symbol) and the selector’s <code>ViewThatFits</code> branch, fed in the Reader with the lens and what it is pointed at (“Content · Transcription”). <strong>Not built:</strong> the per-line reader summary and shown level feed from the Step 1.20 row model, so the Reader title does not yet say the reader, the level or the basis symbol.</li> <li><code>source.editor.content-shows-its-tie-to-the-lines</code> — <strong>[GAP]</strong> (#6458; owner 2026-11-08 22:05: it is not clear how Content connects to Lines. Code: the Content view’s text comes with SPANS back to the lines and their readings (<code>DerivedText.spans</code>: <code>segment_id</code>, <code>representation_id</code>, <code>start</code>, <code>end</code>; <code>views.page_line_map</code> for the editable web view), a page with no working pass or an edited page text has NO line map and the view is silent about it (<code>reader.edit.read-only-says-why</code>); the tie of a page reading to its lines is <code>checking/tie_text.py</code>’s (tied at the measured threshold, a doubtful stretch with a <code>reject</code> verdict, the untied remainder; <code>source.tie.audit-per-reader-kind</code>), and the glyph set for it is <code>source.tie.indicator-in-the-inspector</code>’s (no glyph read directly, a plain link tied, a yellow link doubtful, a broken link untied; <code>models-chains-and-projects.md</code> Step 3.7); the live link is <code>source.editor.live-link-from-the-reader-to-the-source-pane</code> (#6455)) the Content view SHOWS how its text ties to the lines: a <strong>margin mark per line</strong>, one small glyph in the left margin at each span’s first line of text (the right margin in a right-to-left page), the tie glyph of Step 3.7 for that line’s counting reading, so a page read line by line shows a quiet column of nothing, a page-read-then-tied page shows links, a doubtful stretch a yellow link, and the glyph’s tooltip and accessibility label carry the words (“tied from Gemini’s page read · 80 %”); <strong>text that is only page-level</strong> (the remainder, or a page with no line map at all) is shown plainly as such: the untied stretches in the Untied block of <code>source.tie.untied-remainder-kept-and-shown</code> with the broken link and the one-line state “page text, not tied to lines” in the view’s head line (where <code>reader.edit.read-only-says-why</code> says why typing is refused), with Tie Automatically and Tie by Hand (#6415) there, never a wall of words with no way back; <strong>clicking lights the line</strong>: a click on a margin mark or in a span’s text selects that line, the span’s background lights in Content, the row lights in the Lines lens and the Preview’s line box and label light through the live link (the Reader posts on <code>.readerTextSelection</code> and sets the focused <code>RegionSelection</code>, as #6455 specifies; nothing new), and moving the click moves it; <strong>a shown level follows #6443’s level rules</strong> (<code>source.tie.level-reading-is-tied-to-the-lines</code>): a level reading made per segment is anchored and shows no glyph, one tied from a whole-page run shows the link, a parked one is in the Untied block at its level. Defaults, noted (no owner question): the margin shows the glyph only, no line numbers (the Lines lens is the numbered view); the marks stay at every width (one glyph); a line whose span is empty (a line with no counting reading) shows the dash. Acceptance: a page read by Kraken shows no margin marks and clicking a line lights it in Content, Lines and the Preview; a page read by Gemini whole and tied shows a link per line, two yellow where doubtful, and its remainder in the Untied block with the two verbs; a page with no line map shows “page text, not tied to lines” in the head line; Modernised shown on a page normalised per segment shows no marks, on a page normalised whole shows links. <em>Test:</em> <code>ContentTieMarksTests.swift</code> (not yet written: the margin-mark rules, the head line, the Untied block, the click publishing on the two seams and the level rules), the existing <code>test_tie_text_to_lines.py</code> for the figures the glyphs read and <code>DisagreementWiringTests.swift</code> for the seam. <em>Spec change:</em> 2026-11-08 22:10, the owner’s #6458; Step 3.7’s bullets and #6455’s untouched, read from here. <strong>Built:</strong> nothing yet in the app. <strong>Not built:</strong> the mark rules (anchored, tied, doubtful, empty; a tie with no score is still a tie) and the head line, drawing the margin marks in the Content view’s spans, the head line, the Untied block, the click on the two seams of #6455; the doubtful line 0.6 is a placeholder for the measured threshold row.</li> <li><code>source.editor.page-level-reading-of-any-level-is-tied-automatically-then-by-hand</code> — <strong>[GAP]</strong> (#6458; owner 2026-11-08 21:46 and 22:15: a Regularised page text in the centre column, the lines on the left, no way between them; tying must be automatic when it can be, the explicit action the fallback. Code: <code>checking/tie_text.after_page_reading</code> queues <code>tie-text-to-lines</code> only for the page’s TRANSCRIPTION artifact, so a page-level reading of any other level or kind (a Normalise run on the whole page, a translation) is never tied (<code>source.tie.level-reading-is-tied-to-the-lines</code>, <code>models-chains-and-projects.md</code> Step 3.7, iterated here for the view); the tie writes one line reading per tied line through <code>representation.create</code> with <code>derived_from_artifact_id</code> and <code>machine_confidence</code>, a doubtful stretch with a <code>reject</code> verdict and the rest as remainder; <code>representation.retract_many</code> / <code>unretract_many</code> exist as one undoable pair) <strong>a page-level reading of ANY level or kind is tied AUTOMATICALLY when it can be</strong>, as a page reader’s text is today: the tie job runs by itself after the reading is made (<code>after_page_reading</code> fires for every kind and level, not the transcription alone), aligning against the lines’ counting text at the level the reading derived from (as written for a level made from as written, the working text for a translation), at the measured threshold row of its reader kind (<code>source.tie.thresholds-are-measured</code>; a “level reading” and a “translation” row); a TRANSLATION is tied to REGIONS or paragraphs, never line for line: the unit of alignment is the region (its lines’ counting text joined in reading order), one derived translation reading per region, since a translation does not keep the lines’ breaks; the result is SHOWN PLAINLY as states, never silently: tied, doubtful, untied and draft as the glyphs of <code>source.tie.indicator-in-the-inspector</code> on the margin marks of <code>source.editor.content-shows-its-tie-to-the-lines</code>, the Levels rows and the page’s figures, with the measure in the tooltip (“tied 38 · doubtful 2 · untied 1 · 0.72”); <strong>the explicit action is the fallback</strong>: <strong>Tie to Lines</strong> and <strong>Tie to Regions</strong> on the page-level reading’s row (the Levels section, the Untied block, the Content view’s head line when the shown level is page-only), each the existing check run (<code>POST /api/check/runs</code>, <code>tie-text-to-lines</code>) with the chooser of #6415 for the model or aligner, shown with its measure when done, and <strong>Tie by Hand</strong> as #6415 gives it; a tie is UNDOABLE as one set: the job’s writes are retracted together (<code>representation.retract_many</code> over the run’s readings, the page-level row untouched) and redo un-retracts; <strong>the data is what exists, no new store</strong>: the tie IS the per-segment readings (segment id, <code>level</code>, <code>kind</code>, <code>derived_from_representation_id</code> the page-level row, <code>derived_from_artifact_id</code> its artifact, <code>machine_confidence</code> the line’s score), the page-level row stays as history and is never what a line shows once tied, and the untied stretches are the remainder of Step 3.7; and <strong>clicking a line selects its version in every column and the reverse</strong>: a line’s selection (the focused <code>RegionSelection</code>, #6455) lights that line’s reading in every lens and column showing the page (Content at the shown level, Lines, Compare with levels as sides) and clicking a stretch in a tied page text selects its line. The levels a line can carry are the shipped five plus translation (<code>BUILTIN_READING_LEVELS</code>: graphemic, as written, expanded, regularised, modernised; kind <code>translation</code> with its language tag; the owner’s words graphic, literal, regularised, modern, translation name the same rows), and the Reader’s and Lines lens’s switcher is the shared <code>shownLevel</code> of <code>source.editor.levels-shown-side-by-side-and-switched</code>. Acceptance: a Regularise run on a whole page writes the page-level reading and the tie job runs by itself, the Content view at Regularised shows link marks per line and clicking line 7 lights line 7 in Lines and the Preview; a translation run ties per region and Content at the translation shows one mark per region; a page whose level text did not tie shows the Untied block with Tie to Lines, which runs the check and reports “tied 38 · doubtful 2 · untied 1”; ⌘Z retracts the 40 readings as one and the block returns. <em>Test:</em> <code>test_any_page_level_reading_is_tied_6458.py</code> (not yet written, red first: <code>after_page_reading</code> for every kind and level, the region unit for a translation, the set undo), <code>TieToLinesVerbsTests.swift</code> (not yet written; the verbs on the row, the states shown, the selection across columns), the existing <code>test_tie_text_to_lines.py</code> and <code>test_level_reading_is_tied_6443.py</code> named on Step 3.7. <em>Spec change:</em> 2026-11-08 22:15, the owner’s #6458; Step 3.7’s bullets untouched, iterated here for the view and the automatic run. <em>Note 2026-11-11 (owner: “the engine doesn’t seem to tie page to the lines; we want that to happen, and the user should see it”), the code’s silent skips, to reproduce in the app:</em> <code>after_page_reading</code> is called from one place only (<code>workflows/tools/llm_base.py</code>, after an LLM tool saves a page reading), and returns nothing, logged nowhere, when (a) the page has no lines yet, and nothing ties it once Find Lines or a conversion gives it lines; (b) no Kraken recognition model is on this Mac (<code>rough_reader</code> is None); (c) the reading is flagged or is the lines’ own text; (d) the page text came by import (<code>format.import</code>, Import Page Text), was typed, or is not a transcription. So: the tie is queued from every writer of a page-level reading AND when a page gains lines; when it cannot run, the page records why (“not tied: no lines”, “not tied: no line reader installed”) and the Content view’s head and the Inspector show it with Tie to Lines.</li> <li><code>source.editor.a-reading-records-who-made-it</code> — <strong>[PARTIAL]</strong> (#6458; owner 2026-11-08 22:15: a recipe step today does not give us the model. Code: a <code>ContentRepresentation</code> has <code>producer_model</code>, <code>producer_tool</code>, <code>producer_run_id</code>, <code>level</code>, <code>kind</code>, <code>derived_from_representation_id</code>, <code>derived_from_artifact_id</code>, <code>created_at</code>, <code>review_state</code>, <code>machine_confidence</code>; a step’s line readings through <code>working_lines.write_readings</code> record <code>level</code>, <code>derived_from_*</code> and the run id but NOT the model, which lives on the artifact (<code>Artifact.model</code>, <code>provider</code>); the tie’s readings (<code>tie_text</code>) record only <code>derived_from_artifact_id</code> and <code>machine_confidence</code>; so the reader of a line’s version is found by a join (<code>compare_readings._reader_of</code>: the artifact’s model, else <code>producer_model</code>, else the provider, else the tool, else “a reader”)) every reading a step, a reader or the tie writes RECORDS WHO MADE IT on the row itself: <code>producer_model</code> (the model id the run chose, <code>llm.run_model_choice</code>, with its provider prefix), <code>producer_tool</code> (the step’s job id, <code>read-a-page</code>, <code>normalise</code>, <code>tie-text-to-lines</code>), <code>producer_run_id</code> (the task), <code>level</code> and <code>kind</code>, <code>derived_from_representation_id</code> and <code>derived_from_artifact_id</code>, and <code>created_at</code>; the writer fills them from the run and the artifact in the one place each writes (<code>write_readings</code>, the tie’s <code>representation.create</code> call), the prompt and the provider’s answer stay on the artifact and the run record (not copied per reading), and the row points at them; a reading with no model (a person’s, an import’s) records the person or “file: <name>” in <code>producer_tool</code> as imports do today; so a line’s versions are labelled “reader · model · level · when” from the row alone, which is what the switcher, the Levels section, the popover and the newest-first list of <code>source.editor.content-listed-newest-first-in-the-pane</code> print. Acceptance: after a Normalise step the line’s regularised reading row carries the model id, the job id, the run id and the level; after a tie the tied line reading carries the page reader’s model and <code>tie-text-to-lines</code> as its tool; the Levels row reads “Claude Sonnet · regularised · 21:46” without a second request. <em>Built:</em> <code>representation.create</code> takes <code>producer_model</code> and <code>producer_tool</code> and keeps them on a machine’s reading; a tied line carries the page reader’s model (provider-prefixed) and <code>tie-text-to-lines</code>; <code>working_lines.write_readings</code> records the model of the artifact it came from and a <code>tool</code> where the caller names one. <em>Built:</em> a reading a workflow step writes through <code>write_readings</code> records the step’s job id (<code>NodeContext.tool</code>, the node’s tool) in <code>producer_tool</code>. <em>Not built:</em> the Levels row and switcher printing the maker from the row. <em>Test:</em> <code>test_a_reading_records_who_made_it_6458.py</code> (written for the tie, <code>write_readings</code> and a workflow step’s job id), the existing <code>test_reading_levels.py</code> and <code>test_tie_text_to_lines.py</code>. <em>Spec change:</em> 2026-11-08 22:15, the owner’s #6458.</li> <li><code>source.editor.live-link-carries-a-set-of-lines</code> — <strong>[GAP]</strong> (#6455; owner 2026-11-08 22:20: selecting several lines in the Reader must light ALL of them in the Preview and select them in the Inspector, not the first alone. Code: the seam already carries a RANGE (<code>postReaderSelection(range, documentId:, content:)</code>: UTF-16 offsets into the displayed transcript) and the Preview lights every word box whose span intersects it (<code>wordBoxes(intersecting:)</code>); the focused <code>RegionSelection</code> is a SET of segment ids (<code>InspectorPath.selectedSegmentIds</code>); the live link of <code>source.editor.live-link-from-the-reader-to-the-source-pane</code> is written for one word) the live link carries a SET: a Reader selection spanning several lines (a drag in the Content lens, ⇧-click or ⌘-click rows in Lines, a run of words in the disagreement lens) posts the whole range on <code>.readerTextSelection</code> and sets the focused <code>RegionSelection</code> to EVERY line the range touches (through the line map, the span’s lines; the word segments where the page has them), so the Preview lights every box the range intersects and pins the label of <code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code> once per lit line (one label when the lines share a maker and level, “3 lines · Claude Sonnet · as written ✓”), and the Inspector shows the multi-selection as it does for any set (<code>inspector.multi-selection.acts-at-once</code>); EXTENDING or SHRINKING the selection updates all three LIVE on every change, no extra step, as the range posts today; clearing clears. Acceptance: dragging across lines 3 to 5 in Content lights the three lines’ boxes in the Preview and the Inspector shows three segments; extending the drag to line 6 lights a fourth box as the drag moves; ⌘-clicking two non-adjacent rows in Lines lights both; ⌘A in the Reader (decision 3) lights every line. <em>Test:</em> <code>ReaderToSourceLiveLinkTests.swift</code> named on Step 1.20 extended (not yet written; a range over several lines gives the set of lines, the boxes and labels per line, a change re-posts, a clear clears), the existing <code>ReaderPreviewLinkingTests.swift</code>. <em>Spec change:</em> 2026-11-08 22:22, the owner’s #6455 comment; the one-word bullet untouched, widened here.</li> <li><code>source.editor.run-a-workflow-on-content-and-on-the-latest</code> — <strong>[GAP]</strong> (#6460, #6461; owner 2026-11-08 22:25: no clear way to run a workflow on a page’s content or on the most recent piece of it, “Translate the latest reading”. Code: a workflow run’s target is a <code>WorkflowSelection</code> of kind documents, folder, collection, group or segments with ids (<code>workflows/selection.py</code> <code>SelectionKind</code>), resolved and SAID before the run (<code>WorkflowRunScope.Resolution</code>: “Runs on N documents”, #4396, #4414); Run Workflow ▸ is ONE component on every surface (<code>FocusedCommandButtons+RunAndChatVerbs.swift</code>, <code>menus.project.run-and-chat-one-component</code>), Run the Recipe on This Item is ⌥⌘R and Run Workflow on Selection… loses its chord (section 4 of <code>ui/menus-and-commands.md</code>); the prior art is <code>agent-work/plans/2026-07-24-context-menu-run-workflow-targets.md</code>; a step’s reading records what made it (<code>source.editor.a-reading-records-who-made-it</code>); no target names a READING) a workflow can be run ON A PIECE OF CONTENT: the target is a READING (a <code>ContentRepresentation</code> row: a page-level reading, a line’s reading at a level, a translation), as ONE contract addition, named: <code>SelectionKind.readings</code> with the reading ids, resolved and said before the run as every scope is (“Runs on 1 reading: Regularised by Claude Sonnet, 21:46”), recorded in the run record as the other kinds are; and <strong>“the latest”</strong> is a target the person can name without picking a row: <strong>Run on the Latest Content</strong> resolves AT RUN TIME to the page’s newest reading of the kind the step reads (the first row of <code>source.editor.content-listed-newest-first-in-the-pane</code>, by <code>created_at</code>), says which it resolved to before running, and records the resolved id in the run record, never the word “latest”; <strong>the step takes the chosen content as its INPUT</strong> (#6461): a step given a reading reads THAT text, not the page’s working text (Regularised → Translate to Spanish reads the regularised reading), its output is a NEW reading <code>derived_from_representation_id</code> the input, at the step’s own level and kind (<code>source.editor.step-line-reads-and-writes-a-level</code>), with the model and step recorded on the row (<code>source.editor.a-reading-records-who-made-it</code>), and the new reading appears at the top of the newest-first list with its maker, so the chain Regularised → Spanish is visible as two rows that point at each other; a page-level input yields a page-level output tied by <code>source.editor.page-level-reading-of-any-level-is-tied-automatically-then-by-hand</code>. <strong>Where it lives</strong> (three homes, one component, the #6435 table): the Reader pane’s lens ▾ title menu gains <strong>Run Workflow ▸</strong> on the shown reading and <strong>Run on the Latest Content ▸</strong>; the context menu of a reading’s row (the Levels section, the Content tab’s newest-first list, the popover of <code>source.disagree.popover-lists-every-reader-and-the-lines-other-readings</code>) renders the same Run Workflow ▸ on THAT reading; the Inspector’s Content tab row has it too; and EVERY ARTIFACT ROW, wherever one is listed (the Inspector’s Artifacts tab, <code>ArtifactPanel</code>; the sidebar’s artifact rows; the newest-first content list; the Library’s item list when an artifact is the item), has the same context menu, <strong>Run Workflow on This Artifact ▸</strong>, a submenu of the workflows that ACCEPT that artifact’s kind as input (the plan’s acceptance rule, <code>agent-work/plans/2026-07-24-context-menu-run-workflow-targets.md</code>; an artifact that no workflow accepts shows the item disabled with the reason), with Run on the Latest Content ▸ beside it, the target the artifact’s reading where it has one (<code>SelectionKind.readings</code>) else the artifact itself as the plan’s artifact target; one component, the same scope sentence; the command table gains one row, Project › Workflows ▸ Run Workflow ▸ on a reading, surfaces R and I, NO chord (the audit’s rule: ⌥⌘R stays the recipe’s, Run Workflow ▸ is a submenu), icon the existing workflow glyph. Acceptance: right-clicking the Regularised row and choosing Run Workflow ▸ Translate to Spanish says “Runs on 1 reading: Regularised by Claude Sonnet, 21:46”, runs, and a Spanish translation row appears first in the list, derived from the regularised one, labelled with the model; Run on the Latest Content ▸ Translate on a page whose newest reading is that same row resolves to it and says so; the run record names the reading id, not “latest”. <em>Test:</em> <code>test_workflow_runs_on_a_reading_6460.py</code> (not yet written, red first: the readings kind resolved and said, the latest resolved at run time and recorded by id, the step reading the input’s text, the output derived_from it with model and step on the row), <code>RunWorkflowOnContentMenuTests.swift</code> (not yet written; the three homes render the one component on the reading; the scope sentence), the existing <code>RunAndChatMenuTests.swift</code> and <code>MenuTableTests.swift</code> named on <code>menus.one-command-table</code>. <em>Spec change:</em> 2026-11-08 22:26 and 22:36, the owner’s #6460 and #6461.</li> <li><code>source.editor.content-listed-newest-first-in-the-pane</code> — <strong>[PARTIAL]</strong> (#6460; owner 2026-11-08 22:25: content should be listed in order of extraction, newest first, visibly, not hidden in menus. Code: the artifacts route sorts non-page artifacts newest first but a page’s child artifacts BY PAGE ORDER (<code>artifacts.py</code> <code>_sort_key</code>, #1271); the segment readings list (<code>GET /api/segments/{segment_id}/readings</code>) comes back in query order with no sort; the Inspector has a Content tab and an Artifacts tab (<code>InspectorTab.content</code>, <code>.artifacts</code>, <code>ArtifactPanel</code>); the Levels section lists by level, not by time) <strong>a page’s content is ONE list, newest first by <code>created_at</code>, shown in the pane</strong>: every reading and artifact of the page (page-level readings, the lines’ readings grouped as one row per run, translations, named artifacts, imports) as rows “when · reader or person · model · level · kind” with the counting mark and the tie glyph, newest at the top so the most recent is obvious; the list lives in TWO places from one row model: the Inspector’s Content tab (replacing its level-first order; the Artifacts tab keeps its own list) and the Reader’s Content view as a <strong>Versions strip</strong> under the pane head, one line by default showing the newest row and the count (“Regularised · Claude Sonnet · 21:46 · 4 versions”), expanding on click to the list, clicking a row SHOWS that reading in the view (the shared <code>shownLevel</code> follows when the row is a level, a page-level row shows that text with its tie marks), the shown row marked; the Reader’s artifact lens ALREADY groups the page’s artifacts by run, newest run first (<code>ReadingPaneView.artifactLensGroups</code>, 2026-09-04): the strip and the Content tab are that grouping extended to readings and levels, built on it, not beside it (<code>iterate-never-replace</code>); the engine orders both answers newest first (the readings list gains <code>ORDER BY created_at DESC</code>; the artifacts route sorts a page’s children newest first too, the page-order sort kept for the document-wide list that #1271 wanted); the text budget holds (no sentence in a row). Defaults, noted (no owner question): the strip is collapsed to one line; a line’s readings appear as one row per run, not one per line; “when” is the short relative time with the full date in the tooltip. Acceptance: after a Regularise run and a Translate run the Content tab lists Spanish, Regularised, As written in that order with their makers and times; the Reader’s strip reads “Spanish · Claude Sonnet · 22:30 · 3 versions” and clicking it then Regularised shows the regularised text with its tie marks; the most recent reading is the first row everywhere. <em>Test:</em> <code>test_content_listed_newest_first_6460.py</code> (the readings list ordered by created_at desc; a page’s artifacts and one row per run are next), <code>ContentVersionsStripTests.swift</code> (next, not built; the rows from the one model, the collapsed line, the click showing the reading, the shown mark), the existing <code>test_reading_levels.py</code>. <em>Spec change:</em> 2026-11-08 22:26, the owner’s #6460. Built 2026-11-09 - engine, #6460: <code>GET /api/segments/{segment_id}/readings</code> returns the readings newest first by <code>created_at</code>, pinned by <code>fichero-server/tests/unit/api/test_content_listed_newest_first_6460.py</code>. Not built: a page’s child artifacts newest first, the row model, the Versions strip and the Content tab.</li> <li><code>source.editor.compare-two-to-four-readings-with-the-line-picture-and-edit-in-line</code> — <strong>[PARTIAL]</strong> (#6462; owner 2026-11-08 22:40: in Reader › Content a comparison of 2, 3 or 4 readings should show the line’s image with each row and let any compared reading be edited in place. Code: the Compare component (<code>CompareViewModel</code>: Side by Side, Overlay and Wipe; <code>Row</code> with <code>texts</code> per reader, <code>differs</code>, <code>differingWords</code>, <code>countingReaderId</code>, <code>canPick</code>; <code>Pick</code> sends the segment, the reading and the one that counted; the view <code>CompareReadersView</code>) reads <code>GET /api/documents/{page_id}/compare-readers</code>, whose lines carry <code>picture</code> (a storage reference to the line’s cut, <code>GET /api/segments/{id}/picture</code>) and every reader’s text as written with its <code>representation_id</code> (<code>source.compare.readers-answer</code>); the Reader’s split panes compare two artifacts or Content beside Translation (<code>ReadingPaneView.artifactLens</code>, <code>readerRepresentation</code>); the Lines lens’s row is the in-line editor (<code>ReaderLineRow</code> over <code>ReaderLineEditor</code>: the line’s picture, its counting reading in a field, Save as the Inspector’s own save through <code>representation.create</code> with the stale check, Revert, one ⌘Z, <code>reader.lines.image-above-text</code>); a compared reading is read-only today (<code>reader.edit.not-a-reading-is-read-only</code> for passes); the disagreement lens tints words and its popover lists variants (<code>source.disagree.lens</code>, <code>source.disagree.popover-lists-every-reader-and-the-lines-other-readings</code>)) <strong>a comparison in Reader › Content takes 2 to 4 readings</strong> (readers’ lines, levels as sides per <code>source.disagree.levels-as-sides</code>, a person’s correction, chosen from the newest-first list of <code>source.editor.content-listed-newest-first-in-the-pane</code> through the lens title’s Compare ▸ menu; a fifth is refused in one line), <strong>shows the line’s picture with each row</strong> (the <code>picture</code> the compare answer already carries, drawn as <code>ReaderLineRow</code> draws it, one picture per line above or beside the 2 to 4 texts, in the Overlay and Wipe modes once as today), and <strong>edits any compared reading in line</strong>: each compared text is <code>ReaderLineRow</code>’s field, the SAME editor, not a second one (<code>source.textedit.no-second-path</code>): Save writes a NEW reading <code>derived_from_representation_id</code> the compared reading at ITS level and kind (a correction of the regularised reading stays regularised), never overwriting (readings are immutable), through the one save path with the stale check, the person recorded as the maker (<code>provenance_kind</code> human, <code>producer_tool</code> the person; a model’s reading keeps its model on the row it derived from), one ⌘Z retracting it; Revert puts the words back; the edited column shows the new reading with the person glyph and the old one stays in the switcher’s history. <strong>How it sits with Where the Readers Disagree and the live link</strong>: the disagreement lens stays the WHOLE-PAGE map (every reader, tints, the popover) and this is the per-line WORKBENCH on 2 to 4 of them, reading the same compare answer (<code>source.compare.readers-answer</code> reuses the disagreement’s alignment, so the differing words tinted in a row are the map’s); a click on a row’s word or picture publishes on the two seams of <code>source.editor.live-link-from-the-reader-to-the-source-pane</code> (#6455), so the Preview lights the line and pins the label of the reading clicked, and the Preview’s or the map’s selection scrolls the comparison to that line; Make This Count on a row is the pick (<code>source.compare.pick</code>). Acceptance: Compare ▸ with Kraken, Gemini and the Regularised level shows three columns with the line’s picture per line; typing in Gemini’s cell on line 4 and Save writes one reading derived from Gemini’s at as written with the person glyph, the Inspector lists both, ⌘Z retracts it; clicking line 4’s picture lights line 4 in the Preview with Gemini’s label; a fifth reading is refused in one line. <em>Test:</em> <code>CompareInLineEditTests.swift</code> (the rule and the correction are built, the view is next; 2 to 4 readings and the refusal, the picture per row, the save through the one editor with derived_from and level, the live link post), the existing <code>CompareViewTests.swift</code>, <code>test_compare_readers_5900.py</code> and <code>test_correct_a_line.py</code>. <em>Spec change:</em> 2026-11-08 22:40, the owner’s #6462; <code>source.compare.*</code> and <code>source.disagree.*</code> untouched. Built 2026-11-09 - Swift model only, #6462: the 2 to 4 rule and the correction an edit writes are <code>CompareInLineEdit</code>, pinned by <code>fichero/Tests/Unit/general/Models/CompareInLineEditTests.swift</code>. Engine, #6462: <code>POST /api/segments/{id}/correct</code> takes <code>corrects_representation_id</code>, so an edit of a compared reading derives from THAT reading at its own level and kind, pinned by <code>test_correct_a_chosen_reading_6462.py</code>. Not built: the view, the picture per row and the live-link seams.</li> <li><code>source.editor.parallel-text-view</code> — <strong>[GAP]</strong> (#6463; owner 2026-11-08 22:45, the flagship example: page 6_Hoja_3_Verso, its Spanish modernised and regularised text line-broken, beside a one-paragraph English translation. Code: the Compare component takes LEVELS as sides (<code>source.disagree.levels-as-sides</code>, <code>CompareViewModel</code>, the compare answer’s <code>levels=a,b</code>), the Reader’s split panes show Content beside Translation (<code>ReadingPaneView.readerRepresentation</code>), a translation is a reading of kind <code>translation</code> with its language tag and a page-level row when made on the whole page (<code>start.py</code>’s translate config, <code>source.editor.page-level-reading-of-any-level-is-tied-automatically-then-by-hand</code>), the shown level is one shared <code>shownLevel</code> per window (<code>source.editor.levels-shown-side-by-side-and-switched</code>), and the page’s content is listed newest first (<code>source.editor.content-listed-newest-first-in-the-pane</code>)) the Reader has a <strong>Parallel Text</strong> view, a mode of the Compare component in Reader › Content, not a new pane kind: on the LEFT the source text at one or two levels the person picks (modernised and regularised Spanish, line-broken, each line with its margin tie mark), on the RIGHT one or more TRANSLATIONS as PROSE paragraphs (a translation keeps its own paragraphing, never the lines’ breaks), each column headed by its label from the one row model (“English · Claude Sonnet · 2026-11-08” / “English · <person> · 2026-11-02”); the translations are chosen from the newest-first list through the column head’s menu, <strong>selectable</strong> (one at a time, the head’s menu switching) or <strong>side by side</strong> (two or three translation columns; a fourth side is refused in one line as <code>source.editor.compare-two-to-four-readings-with-the-line-picture-and-edit-in-line</code> refuses), the source side following the shared <code>shownLevel</code> and the switcher; a translation column is editable in line by the same editor as that bullet gives (a new translation reading derived from the shown one, the person recorded, one ⌘Z), and its clauses re-align by <code>source.editor.translation-aligned-by-clause-to-line-ranges</code> when saved. <strong>Export hook</strong> (named only, specified in <code>export/open-standards-profile.md</code>): <code>profile.views.levels-and-translations-have-a-place</code> carries the parallel text to TEI with <code>@corresp</code> on each translation <code><seg></code> naming the segment ids its alignment row holds, and <code>profile.edition.pages-facing-and-apparatus</code>’s text–translation facing layout places each clause against the line range it covers; <strong>Export as Parallel Text</strong> in the Reader’s File › Export ▸ is that bundle view and nothing more here. Acceptance: on the example page Parallel Text shows modernised and regularised Spanish line by line on the left and the English paragraph on the right with its model and date; adding a second English translation from the list shows two prose columns with their labels; switching the shown level to As written changes the left side alone; a fourth column is refused in one line. <em>Test:</em> <code>ParallelTextViewTests.swift</code> (not yet written; the sides from the levels and the translations, the labels, the one-to-three rule, the shared level), the existing <code>CompareViewTests.swift</code> and <code>ShownLevelTests.swift</code> named on Step 1.17. <em>Spec change:</em> 2026-11-08 22:45, the owner’s #6463, composed from #6458, #6443, #6460 and #6462.</li> <li><code>source.editor.reader-shows-versions-of-a-segment-on-request</code> — <strong>[GAP]</strong> (#6463; owner 2026-11-10, needs thought before building) the segment Reader can show, when the person chooses, the other versions of what is selected beside it on the same page: a line, a word or a character with its modernised, regularised and translated readings, and related segments. The choice sits in the Reader’s display menu at the bottom (the metadata icon), off by default, one switch per version kind. A version that is not tied to a line (a translation by clause, the untied remainder of <code>models-chains-and-projects.md</code> Step 3.7) is shown too, in its own place, never dropped. It reuses <code>source.editor.parallel-text-view</code> (the Compare component) rather than a second view. <em>Open:</em> the layout when the selection is a word or a character, and how an untied reading is placed; ask the owner with a sketch. <em>Test:</em> not yet written.</li> <li><code>source.editor.reader-line-discloses-its-versions</code> — <strong>[GAP]</strong> (#6492; owner 2026-11-10: a line read by Kraken, then Google, then modernised from Google’s reading, should show that history in the line Reader with disclosure triangles) a line in the segment Reader with more than one reading carries a disclosure triangle; closed, the line shows the reading that counts, as now. Open, its readings show beneath it as a tree: a reading made FROM another reading of the line (<code>derived_from_representation_id</code>: a modernisation, a regularisation, a translation) or correcting one (<code>corrects_representation_id</code>) sits under that reading, indented; every other reading is a top-level row. Siblings run oldest first. Each row names who made it (the person, or the model and provider of the pass, <code>producer_model</code>/<code>producer_provider</code>), what it is (kind, level, language: “Transcription, modernised”, “Translation, English”) and when, and the reading that counts carries a check. A line with no reading shows “No reading yet” and no triangle. ⌥-click on a triangle opens or closes every line on the page, as in Finder; on iPad and iPhone a click opens the one line, since SwiftUI reports held modifier keys only on the Mac. A reading whose parent is retracted or not on this line is a top-level row, never dropped; a retracted reading is shown only under the Display menu’s “Show Withdrawn Readings”. Reading only: choosing which reading counts stays in the Inspector (<code>source.reading.chosen-is-worked-out</code>). Words and characters follow the same tree once a line works. <em>Test:</em> the tree is a pure function of the readings list (<code>ReadingTreeTests.swift</code>): roots, derived and corrected children, oldest-first siblings, an orphan’s parent missing, a retracted reading hidden; the drawing: not run.</li> <li><code>source.editor.segment-row-is-the-same-in-every-lens</code> — <strong>[GAP]</strong> (first slice, the Segments List lens’s other readings and shown label, is <code>source.editor.segments-list-shows-other-readings-under-rows</code>; #6492, #6463; owner 2026-11-11: “in an easy to edit view, the hierarchy, plus images, then the various renditions indented”, “for all the segment options”) ONE segment row, built from one model (the picture, the shown reading, every reading as the tree of <code>source.editor.reader-line-discloses-its-versions</code>, the facts of <code>source.editor.segment-row-shows-its-facts-as-icons</code>), is what every surface that lists segments draws: the Reader’s Lines view and Content view, the Segments pane’s three lenses (List, Strip, Grid: <code>SegmentsPane.Lens</code>), the Inspector’s children list and the Order list. List draws the hierarchy (region › line › word, from <code>SegmentsPane.outline</code>) with each segment’s picture (<code>SegmentPictureService.picture</code>, any kind) and its readings indented beneath; Strip and Grid draw the picture as the tile with the shown reading and icons as its caption and the other readings on disclosure. Any reading shown is edited in place through the one editor (<code>source.editor.compare-two-to-four-readings-with-the-line-picture-and-edit-in-line</code>: <code>POST /api/segments/{id}/correct</code> with <code>corrects_representation_id</code>, built). A reading can also be shown beside the others on the same line (<code>source.editor.levels-shown-side-by-side-and-switched</code>). One change updates its one row in place, never the list. The Order list’s label becomes the shown reading, not the raw <code>Segment.text</code>. Acceptance: a line read by Kraken and Gemini and modernised shows, in List, Strip and Grid and in the Reader, the same picture, the same shown reading and the same three readings; editing Gemini’s in Grid writes one reading derived from it and every surface shows it. <em>Test:</em> <code>SegmentRowModelTests.swift</code> (not yet written: one model feeds all lenses, the tree, the in-place update).</li> <li><code>source.editor.segments-list-shows-other-readings-under-rows</code> — <strong>[PARTIAL]</strong> (#6492; first slice of <code>source.editor.segment-row-is-the-same-in-every-lens</code>, built 2026-11-11; seen in the build, not yet in the running app. Not built: the Strip and Grid lenses, the Reader, the Inspector’s children list, editing a reading in place, the shown label where no reading counts (the newest person’s, as <code>ShownReadingLabel</code>), regions’ readings) the Segments pane reads the page’s one compare answer (<code>GET /api/documents/{page}/compare-readers</code>, <code>CompareReadersStore</code>) once per page. Its view menu has an <strong>Other Readings</strong> submenu listing the page’s readers, each with a checkmark, saved per window by the reader’s label (<code>@SceneStorage("segments.otherReaders")</code>), none ticked by default. Each ticked reader’s words sit under every row it read, in caption style, labelled with the reader, in the readers’ order; a reader that did not read the row adds nothing. A row’s label is the counting reading’s words when the answer has one, else the segment’s own text (<code>SegmentOtherReadings.shown</code>, <code>SegmentsPane.showing</code>). <code>ReadingOrderList</code> only takes a <code>rowFooter</code> closure. <em>Test:</em> <code>SegmentOtherReadingsTests.swift</code>.</li> <li><code>source.editor.segments-list-starts-at-the-page-with-its-orders</code> — <strong>[PARTIAL]</strong> (first slice built 2026-11-11, seen in its preview, not yet in the running app: the Segments pane’s list starts with a page row (<code>SegmentsPageRow</code>: the page’s name, its icon and what it holds, “19 lines, 2 regions”, <code>SegmentsPane.pageRow</code>), at the page’s top level only; clicking it clears the shared selection, so the Inspector shows the page, and it is lit while nothing on the page is selected. <em>Test:</em> <code>SegmentsFilterTests.pageRowComesFirst</code>. Not built: the order rows under it (the Order list’s picker, with New Order, New Flow and Previous/Next, stays the one choice of order for now), the order-kind icons, the page row inside the List’s own selection; #6413, #6415; owner 2026-11-11: “at the top should it also say page? so we can see all the components of the page; and then we might have various layout orders or flows that need to be shown there; and more icons of what these all are”. Code: the Segments list’s top level is the shown order’s entries (regions, then their lines, <code>SegmentsPane.outline</code>); the page itself is no row; the page’s orders and flows are only the <code>ReadingOrderPicker</code> menu (“Layout Order”); a row’s only icon is its kind’s (<code>SegmentHierarchy.Level.symbolName</code>)) the list’s first row is the PAGE (its name, its kind’s icon), selectable like any row: selected, the Inspector shows the page (its page-level text and facts) and the Source view selects nothing. Under the page sit its ORDERS, one row each, titled as the picker titles them (<code>source.editor.orders.say-where-they-came-from</code>: the pass’s layout order, a named order, a flow with its flow icon, a flow continuing from another page saying so); the order the list and the Source view show is open with its regions and lines beneath, the others closed, and opening one shows it (the picker and these rows are one choice). Every row carries its kind’s icon and the facts of <code>source.editor.segment-row-shows-its-facts-as-icons</code>; an order’s row carries its kind (layout, named, flow) as an icon. Acceptance: page 7_Hoja_4_Recto lists “7_Hoja_4_Recto.JPG” first, then “Layout Order · working pass” open with Region 1 and Region 3 and their lines, and the other pass’s layout order closed; clicking the page row shows the page in the Inspector. <em>Test:</em> <code>SegmentsListTreeTests.swift</code> (not yet written: the page row, the order rows, the open one being the shown order).</li> <li><code>source.editor.segments-list-has-a-filter-bar</code> — <strong>[PARTIAL]</strong> (#6476; owner 2026-11-11: the list should filter from a bar at its bottom, which it lacked. Built 2026-11-11: <code>SegmentsFilterBar</code> at the bottom of the Segments pane with the search field, the facet menu and “N of M”; Esc clears; <code>ReadingOrderList</code> takes <code>SegmentsFilter.Result</code>, hides rows outside it, dims the ancestors that only hold a match, opens every group, and turns reordering off; the outline is pruned (<code>SegmentsPane.pruned</code>), the strip and grid keep the same rows; the facet menu offers only the page’s values (<code>SegmentsFilter.options</code>); the filter clears with the page. Seen in its preview, not yet in the running app; the owner’s check of “capilla” on page 7 is owed. Not built: the search matching the SHOWN reading rather than <code>Segment.text</code>.) the Segments pane has a filter bar at its BOTTOM, as the Library’s lists do: a search field that matches a segment’s shown reading and its label, accent- and case-blind, and a filter menu beside it with <strong>Kind</strong> (Region, Line, Word, Character), <strong>Reading</strong> (Has a Reading, No Reading, A Person’s, A Machine’s), <strong>Flagged</strong>, <strong>Low Confidence</strong>, <strong>Language</strong>, <strong>Script</strong> and <strong>Direction</strong> (the values the page holds). A row shows when it matches; its ancestors show with it, dimmed, so a line keeps its region; the bar says “12 of 34”. Filtering never changes the selection, and a selected row that no longer matches stays selected. Rows cannot be reordered while a filter is on (a drag between hidden rows has no meaning); the move keys say so. Esc in the field, or the field’s clear button, ends the filter. The rule is one pure model (<code>SegmentsFilter</code>), the same for every lens. Acceptance: typing “capilla” on 7_Hoja_4_Recto leaves the lines whose reading holds it, under Region 3, and the bar reads “3 of 23”; choosing Kind ▸ Region and No Reading shows the regions with no text. <em>Test:</em> <code>fichero/Tests/Unit/general/Models/SegmentsFilterTests.swift</code>.</li> <li><code>source.editor.inspector-segment-pane-is-laid-out-in-groups</code> — <strong>[PARTIAL]</strong> (first slice built 2026-11-11, seen in its preview, not yet in the running app: the segment’s picture first, then titled boxes (<code>InspectorGroupBox</code>) in the order of <code>InspectorSegmentLayout.Group</code>: Readings, Details, History, Links and Rights; Details opens with ONE line, language · script · direction in words (“Spanish · Latin · Left to Right”, <code>InspectorSegmentLayout.detailsLine</code>), where each came from in its tooltip; Hands and Certainty and Damage hide while they hold nothing and the head’s <strong>Add</strong> menu (Hand…, Certainty Mark…) shows them again to use their own verbs; Links stays, without its “No links.” sentence, because it carries Copy Reference; History is the Making section without its picture. <em>Test:</em> <code>InspectorSegmentLayoutTests.swift</code>. Not built: the name with its number in the head, the facts there, one box per reading, Where It Sits, Add choosing the verb itself (today it shows the section), Link and Rights Rule in Add; #6413; owner 2026-11-11: “the Inspector could also do with some UX design, maybe boxes”. Code: <code>SegmentInspectorView</code> stacks its sections as plain headings, shows a section with nothing in it as a heading and a sentence (“No hand is named”, “Nothing is recorded”, “No links”), though its own header says an empty section is hidden; the segment’s picture sits under Making at the bottom; Language, Script and Direction repeat “set by a person, for the project”; Script shows its code (“Latn”); each section names its menu differently (Attribute, Mark, Link, Set)) the segment pane is grouped boxes in the system’s grouped form style (as System Settings and Xcode’s inspectors draw them), labels leading and values trailing, in this order: (1) the head: the segment’s picture, its kind’s icon and its name with its number (“Line 13 · Region 3”), and the facts of <code>source.editor.segment-row-shows-its-facts-as-icons</code>; (2) <strong>Readings</strong>, one box per reading, the counting one first (<code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code>); (3) <strong>Details</strong>: Language · Script · Direction on one row in words (“Spanish · Latin · Left to Right”), where each came from in its tooltip, then Hands and Certainty; (4) <strong>Where It Sits</strong> (<code>source.editor.hierarchy-selectable-with-verbs</code>); (5) <strong>History</strong>; (6) Links and Rights. A group with nothing in it is hidden, and its verb is in ONE <strong>Add</strong> menu in the head (Hand, Certainty Mark, Link, Rights Rule), named as the row menu names it (<code>source.editor.segment-verbs-are-the-same-everywhere</code>). Acceptance: a region with no hand, mark or link shows its picture, its name, Details and Where It Sits, and the Add menu offers the rest. <em>Test:</em> <code>InspectorSegmentLayoutTests.swift</code> (not yet written: which groups show for a segment with and without each fact, the order, the Add menu’s items).</li> <li><code>source.editor.translation-aligned-by-clause-to-line-ranges</code> — <strong>[GAP]</strong> (#6463; owner 2026-11-08 22:45: a translation is prose, not line for line; align by clause or sentence spans to the line ranges they cover, or to the region, automatic, measured, undoable, the model recorded. Code: the tie job aligns a page reading to LINES character by character against the lines’ rough reads (<code>checking/tie_text.py</code>, <code>align</code>, <code>THRESHOLD</code>, <code>remainder</code>); a reading anchors to ONE <code>segment_id</code> (<code>ContentRepresentation.segment_id</code>, <code>source.reading.set</code>), so a clause covering two lines has no anchor; <code>MarkTarget</code> {segment_id, char_start, char_end} spans a stretch of a SOURCE segment’s reading, not a stretch of a translation; <code>readings.replace_stretch</code> carries a stretch over to a new reading of the same text; sentence segmentation exists in the engine’s NLP pass (spaCy, bundled, <code>nlp-layer</code> rulings); <code>source.editor.page-level-reading-of-any-level-is-tied-automatically-then-by-hand</code> ties a translation to REGIONS as its automatic unit) <strong>a translation is aligned to its source by CLAUSE</strong>, automatically and finer than the region tie: after a translation reading is made or edited (the same <code>after_page_reading</code> hook, the translation branch), the engine splits it into SENTENCES and CLAUSES (the NLP pass’s sentence boundaries, clauses at its punctuation and conjunction splits; a span never crosses a paragraph) and ALIGNS each span to the LINE RANGE of the source reading it derived from (the working text’s level at the time, <code>derived_from_representation_id</code>) that it translates, by the tie job’s chooser (<code>source.read.unclear-tie-offers-auto-or-manual</code>: a model asked to map each span to the lines it renders, given both texts with line numbers, or a length-proportional aligner with the page’s names and numbers as anchors when no model is chosen), each span SCORED (the model’s stated confidence or the aligner’s anchor agreement) against a threshold row “translation clause” of <code>source.tie.thresholds-are-measured</code> (<code>design default, TO MEASURE</code> until measured on the Ann sample), below it the span is doubtful and shown so, and a span the aligner cannot place falls back to the REGION the surrounding spans cover (never unanchored, never silent); <strong>the data, named</strong>: ONE new minimal store, <code>reading_alignments</code>, because nothing existing holds “a stretch of THIS reading covers THOSE segments” (a reading has one segment; <code>MarkTarget</code> spans the source side; per-clause derived readings would break the prose and could not span two lines): rows <code>{id, representation_id (the translation), char_start, char_end (code points of it), segment_ids (ordered, lines or a region), score, method (the model id or the aligner's name), producer_run_id, created_at, retracted_at}</code>, written by the alignment run as one audited set and UNDONE as one set (<code>retracted_at</code> on the rows, nothing erased, the translation untouched), the run record carrying the model, the provider and the prompt as every tie run does (<code>source.editor.a-reading-records-who-made-it</code> for the rows’ maker); an EDITED translation (a new reading derived from the old) re-aligns automatically on save, the old rows staying with the old reading as history; after a SPLIT, MERGE or DELETE of a line the rows’ <code>segment_ids</code> follow Step 3.7’s rules (<code>source.tie.audit-per-reader-kind</code>: a split’s two pieces replace the one id, a merge’s one replaces the parts, a deleted line leaves the row with its remaining ids and a doubtful mark); <strong>Re-align</strong> on the translation’s row is the explicit fallback, the same run with the chooser. No new route beyond the rows’ read (<code>GET /api/content-representations/{id}/alignments</code>, the one addition, named; the writer is the existing check run). Acceptance: on the example page the English paragraph aligns into clauses each covering one to three Spanish lines with a score, two doubtful ones marked; editing a clause and saving re-aligns the new reading and the old rows stay on the old one; ⌘Z after an alignment run removes every row of that run as one; splitting line 5 leaves the clause covering lines 4 to 6 covering both pieces. <em>Test:</em> <code>test_translation_aligned_by_clause_6463.py</code> (not yet written, red first: the spans from the NLP pass, each span’s line range and score, the region fallback, the set undo, the re-align on edit, the rows after a split), the existing <code>test_tie_text_to_lines.py</code> and <code>test_tie_after_segments_change_6443.py</code> named on Step 3.7. <em>Spec change:</em> 2026-11-08 22:45, the owner’s #6463.</li> <li><code>source.editor.parallel-text-lights-both-sides-and-the-preview</code> — <strong>[GAP]</strong> (#6463, #6455; Code: the live link’s two seams, <code>.readerTextSelection</code> and the focused <code>RegionSelection</code> (<code>source.editor.live-link-from-the-reader-to-the-source-pane</code>, <code>source.editor.live-link-carries-a-set-of-lines</code>)) in Parallel Text a click on an English CLAUSE lights its source LINES (the alignment row’s <code>segment_ids</code>) in every source column and their boxes in the Preview, with the translation’s label pinned (“English · Claude Sonnet”), through the same two seams, the Reader pane publishing the clause’s segment set; a click on a Spanish LINE lights every clause whose row covers it in every translation column (two translations light each their own clause) and the line in the Preview; a drag over several clauses or lines lights the union live; a doubtful clause lights in the doubtful colour of the tie glyphs; clearing clears. Acceptance: clicking “another, red” lights Spanish lines 3 and 4 in both level columns and their boxes in the Preview; clicking Spanish line 4 lights that clause in the first translation and the differing clause in the second; a drag over three clauses lights five lines. <em>Test:</em> <code>ParallelTextLiveLinkTests.swift</code> (not yet written; clause to lines, line to clauses across columns, the union, the doubtful colour), the existing <code>ReaderPreviewLinkingTests.swift</code>. <em>Spec change:</em> 2026-11-08 22:45, the owner’s #6463.</li> <li><code>source.editor.step-line-reads-and-writes-a-level</code> — <strong>[GAP]</strong> (#6429) every recipe step’s row, in Set Up, Ready and Activity, says “reads <level>, writes <level>“, from the job table (<code>recipes/jobs.py</code> takes and gives) and the step’s settings (<code>reading_level</code> on a Normalise run; readers write as_written; Names, Dates and Statements read the WORKING TEXT, so their line names the level the page or project chose), and the rule is stated once in <code>source/readings-and-apparatus.md</code>’s terms: a step reads the counting reading at the working text’s level unless its row names another, and writes at its own; the Inspector’s Working text badge is that same level. Acceptance: a Normalise step asked for Modernised reads “reads as written, writes modernised”; after Use as Working Text on Modernised the Names step’s row reads “reads modernised”. <em>Test:</em> <code>test_step_line_reads_and_writes_6429.py</code> (not yet written), <code>StepLineLevelsTests.swift</code> (not yet written).</li> <li><code>source.editor.order-list-edits-like-finder</code> — <strong>[PARTIAL]</strong> (#6476; owner 2026-11-09: Finder-style. Code: <code>ReadingOrderList</code> rows are plain text; Return and double-click both call <code>reveal</code>, there is no inline edit) in the Order list (the Inspector’s Order tab and the Reader’s list) Return on the one selected row renames it in place: a line edits its TEXT (the one correction path, <code>CorrectLine</code>, as Correct This Line), a region edits its NAME; Return commits, Esc cancels, a click away commits (Finder). Double-click reveals the row in the Preview (the existing <code>reveal</code>). A click only selects: it does not navigate and the Inspector keeps its tabs. A region has no name today (<code>Segment</code> carries none; the list shows “Region N” by place): the name is one optional field on the segment, set through <code>segment.update</code> with one ⌘Z, shown where it is set and in every list; an unnamed region keeps “Region N”. Acceptance: select a line row, press Return, type, Return: the line’s reading is corrected with one ⌘Z; select a region, Return, type “Inventory”, Return: every list shows “Inventory”; double-click reveals. <em>Test:</em> <code>OrderRenameTests.swift</code> (written; Return on one row begins the edit, on several does nothing, the commit/cancel rules, a line goes to the correction path and a region to the name), <code>test_segment_name_6476.py</code> (still to be written). <em>Note 2026-11-11 (owner: “for the list of segments you have to click to the left of the name, not on the name”):</em> a click ANYWHERE on a row selects it, its words included. Cause: the row’s content carried <code>.draggable</code>, which takes the mouse-down before the List sees it (the Library table’s same fault, #6538); the ROW now drags (<code>View.itemProvider</code> with <code>SegmentDrag.itemProvider()</code>, payload <code>SegmentDrag.forRow</code>), so a click selects and a drag starts only once the pointer moves. <em>Test:</em> <code>fichero/Tests/Unit/general/Models/SegmentDragRowTests.swift</code>.</li> <li><code>source.editor.order-list-selection-shows-everywhere</code> — <strong>[PARTIAL]</strong> (#6476; owner 2026-11-09. Code: <code>selection</code> is the list’s own and <code>extend</code> handles Shift+arrows only) the list takes the usual multi-select (click, ⇧-click range, ⌘-click toggle, ⌥ as the platform gives it, ⌘A in the list); the selection is the shared one, so the same segments are selected in the Segments list and lit in the Preview, and a selection made there shows here (<code>source.editor.live-link-carries-a-set-of-lines</code>). When the Inspector’s list is visible it shows the selection; the list never replaces the Inspector’s tabs. The list’s selection is a SET (today it is one id, so Shift- and ⌘-click select nothing more). Every pane that holds the shared selection draws it in the system selection colour while it has focus and in the grey inactive tone otherwise, so the focused pane is the one in colour (owner 2026-11-09 screenshot: Region 1 blue in the Segments list, Line 2 grey in the Order tab, and nothing says which the window acts on); the pane’s path at the top follows the selection (page › Region 1 › Line 2, a count when several). <em>Test:</em> <code>OrderListSelectionTests.swift</code> (still to be written). <em>Note 2026-11-11 (owner: a row picked in the Segments list reached neither the Source view nor the Inspector):</em> the list wrote the pick as <code>onSelected?(InspectorPath.select(...))</code>; the Segments pane gives no <code>onSelected</code>, and an optional call with no callback never evaluates its argument, so the shared selection was never written there (the Inspector’s Order tab, which passes one, worked). The double-click reveal had the same fault. The write is <code>InspectorPath.selectListPicks</code>, run before the callback; seen in the running app: a row picked in the Segments pane lights its box and the Inspector shows the line. <em>Test:</em> <code>fichero/Tests/Unit/general/Models/ListPicksReachTheSelectionTests.swift</code>.</li> <li><code>source.editor.a-region-has-one-number-everywhere</code> — <strong>[PARTIAL]</strong> (#6476, built 2026-11-11, not yet seen in the running app; owner: “one region numbered differently”. Cause: the Segments pane labelled a row by its place among the rows, so lines folded under an earlier region made the second region “Region 25”, while the Order list numbered regions among the page’s regions) a region is numbered among the page’s regions on every list (the Segments pane, the Order list, the Inspector’s Order section), and any other row by its place, through one rule (<code>SegmentsPane.numberingPlace</code>). <em>Test:</em> <code>SegmentsFilterTests.oneRegionNumbering</code>.</li> <li><code>source.editor.order-list-moves-with-command-arrows</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-09: ⌘↑/⌘↓ move. Code: drag, and ⌥⌘↑/⌥⌘↓ and ⌥⌘⇞/⌥⌘⇟ (to start/end) when the list has focus, all through <code>ReadingOrderMove</code> and <code>store.move</code>; plain ⌘↑/⌘↓ are not bound) ⌘↑ and ⌘↓ move the selected rows up or down one place in the order (the existing ⌥⌘ chords stay, unless the uniqueness test says one chord set is enough), each one audited move with one ⌘Z, the selection kept and scrolled into view; at an end the key does nothing. <em>Test:</em> <code>OrderListMoveKeysTests.swift</code> (not yet written; the target index as a pure function of selection and key, several rows keep their relative order).</li> <li><code>source.editor.order-list-context-menu-and-menu-commands</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-09. Code: the row menu holds Correct This Line and Delete) the row’s menu is the one item table (<code>SegmentMenuContent</code>, Step 1.9): Rename (Return), Reveal, Correct This Line, New Line / New Region, Join, Split, Move Up / Down / To Top / To Bottom, Run Next Step on Selection, Copy, Delete; every item is also a menu-bar command acting on the same selection with a chord that passes <code>MenuShortcutUniquenessTests</code>, and each disabled item says why. <em>Test:</em> <code>OrderListMenuTests.swift</code> (not yet written), the existing <code>MenuShortcutUniquenessTests.swift</code>.</li> <li><code>source.editor.preview-has-three-modes</code> — <strong>[GAP]</strong> (#6482; owner 2026-11-10) the Preview has three modes, chosen by one three-way control in its toolbar, each with a chord: <strong>Read</strong> (the default: look, annotate, highlight, copy; what is drawn is shown, never edited), <strong>Segments</strong> (edit regions, lines, annotations and the order: draw, reshape, move, rename, reorder; the Order list’s edits live here), <strong>Image</strong> (change the pixels: Enhance, Clean up the folder, crop, straighten, rotate, split, and the Edited / original toggle). Today’s single “Edit” is Image. Enhance and Clean up the folder leave the always-visible bar over the picture (#6362’s overlay, <code>SourcePaneImageControls</code>) and sit in Image mode; the full operation set stays as <code>image.ops.edit-mode-offers-every-operation</code> says. <em>Test:</em> a mode-to-controls table (<code>PreviewModeTests.swift</code>, not yet written): Read offers no pixel or structure tool; Segments offers the shape tools and no pixel op; Image offers the pixel ops and no shape tool.</li> <li><code>source.editor.toolbar-follows-the-mode</code> — <strong>[GAP]</strong> (#6482; owner 2026-11-10) the tool row changes with the mode (<code>source.editor.preview-has-three-modes</code>). Read: Select Text, Select Words, Highlight, Line, Text Note, Star, Check; no box tools, and the segment boxes are drawn but not selectable. Segments: Select, Shape (region or polygon), Edit Points (add, move, remove a vertex), <strong>Split</strong> (a knife: draw a stroke across a region or line and it becomes two), Merge, Delete, Rename; no annotation tools. Image: crop, straighten, rotate, split page, Enhance, Clean up the folder. <em>Test:</em> the tool list per mode (<code>PreviewModeToolsTests.swift</code>, not yet written).</li> <li><code>source.editor.split-and-edit-points-are-audited</code> — <strong>[GAP]</strong> (#6482) Split, Merge and Edit Points each send one audited action and undo as one step; a Split gives the two new segments the old one’s parent and places them in its reading-order slot. Needs engine actions (<code>segment.split</code>, <code>segment.merge</code>) if none exists: a builder tell, not app logic. <em>Test:</em> not yet written.</li> <li><code>source.editor.renditions-sit-with-the-flip-arrows</code> — <strong>[GAP]</strong> (#6482) the Renditions menu is one group with the up/down flip arrows, not apart in the pane head; it names the position (“Edited · 2 of 3”) and lists the renditions in flip order, least to most processed, each with a plain label (Original, Enhanced, Deskewed, Edited, SVG). The menu lists only whole-page renditions, never segment pictures. <em>Test:</em> the menu order equals the flip order (<code>RenditionMenuOrderTests.swift</code>, not yet written).</li> <li><code>source.editor.display-menu-has-order-switches</code> — <strong>[GAP]</strong> (#6482; owner 2026-11-10) the Display (What to show) menu holds switches only, no help text and no mode entries: <strong>Shade by Reading Order</strong> (on by default; off, every line is full strength) and <strong>Show Order Numbers</strong> (a small number on each box, in reading order). “Edit Segments” leaves the menu: the mode control at the top owns it. The shade runs light to dark clearly enough to tell first from last (<code>RegionColours.lightestStrength</code> 0.4, was 0.7, which read as one colour across 19 lines); the Order list’s swatches always use the shaded tones, whatever a Preview pane’s switch says (the switch is per pane and changes only that page, #6725). <em>Test:</em> <code>RegionColoursTests.shadeCanBeOff</code> (written); the numbers: not yet written.</li> <li><code>source.editor.selection-is-shared-without-a-preview</code> — <strong>[PARTIAL]</strong> (Reader half built 2026-11-11, not yet seen in the running app: <code>WindowState.pickInReader</code> is the Lines view’s plain click and the Content view’s caret: it selects into <code>sharedRegionSelection</code> (the window’s own with no Preview), reveals in a focused Preview, and, when the selection changed, shows the Inspector on its Content tab (the one <code>.showInspectorTab</code> route; <code>SourceSectionView</code> there shows the Segment pane); the web Reader’s <code>syncSelectedLines</code> reads <code>sharedRegionSelection</code>. <em>Test:</em> <code>LineRevealTests.aReaderPickSelectsForTheWindowAndShowsTheInspector</code>. Left: the Segments pane’s own <code>@State picked</code>; #6482; owner 2026-11-10: selecting a segment in the Reader should update the Inspector) the Reader’s lines, the Order lists and the Inspector share one selection whether or not a Preview is open: the window holds its own (<code>WindowState.windowSelection</code>) and a focused Preview’s takes over (<code>sharedRegionSelection</code>). Selecting a segment also makes the Inspector’s Content tab show that segment. <em>Test:</em> <code>RegionSelectionPerPaneTests.windowSelectionWithoutAPreview</code> (written, not yet run). <em>Note 2026-11-11 (owner, ux2 worker’s reading of the code):</em> clicking a line in the Reader must take you to that line’s Segment pane in the Inspector; today it only mirrors the highlight. Cause: a PLAIN click on a line calls <code>WindowState.revealSegments</code>, which returns nothing when no Preview is focused and never writes <code>windowSelection</code>, while ⌘- and ⇧-click do write it through <code>InspectorPath.select</code> (<code>ReaderLinesView.pick</code>). So: a plain click selects through <code>InspectorPath.select</code> into <code>sharedRegionSelection</code>, THEN reveals in the Preview when one is focused, and shows the Inspector (opened if hidden) on its Source tab through the one <code>.showInspectorTab</code> route, where <code>SourceSectionView</code> already shows the Segment pane for a non-empty selection. The same in the Reader’s Content view (a click or the caret on a line) and the Segments pane (its own <code>@State picked</code> becomes the shared selection read back); the web Reader’s <code>syncSelectedLines</code> reads <code>sharedRegionSelection</code>, not only the focused Preview’s. <em>Test:</em> <code>RegionSelectionPerPaneTests.windowSelectionWithoutAPreview</code>, plus a Reader pick with no Preview writes the window selection (<code>ReaderLinesTests</code>, not yet written).</li> <li><code>source.editor.top-path-names-the-selection</code> — <strong>[GAP]</strong> (#6482; owner 2026-11-10) the path at the very top of the window ends with what is selected, whatever it is: a segment (“Line 4”), several (“3 lines”), a region, a rendition (“Edited”) or an artifact; the Reader pane’s path already does this for segments (<code>SegmentCrumbs</code>). <em>Test:</em> <code>SegmentCrumbsTests</code> extended for region, rendition and artifact (not yet written).</li> <li><code>source.editor.kind-has-its-own-icon</code> — <strong>[GAP]</strong> (#6482; owner 2026-11-10: dots for regions and lines are not enough; icons for regions, lines, segments, polygons, baselines, and characters, words, glyphs, symbols) every segment row and selection mark shows an icon for its KIND in place of the plain dot, in its region’s hue and reading-order shade: region <code>rectangle.dashed</code>, line <code>text.alignleft</code>, word <code>textformat.abc</code>, character <code>character</code>, glyph <code>a.square</code>, symbol <code>asterisk</code> (DRAFT: the owner confirms the set). A segment drawn as a polygon, a baseline or a point carries a second, smaller mark beside it (<code>pentagon</code>, <code>line.diagonal</code>, <code>smallcircle.filled.circle</code>); a plain box carries none. ONE table (<code>SegmentKindIcon</code>) serves the Order list, the Reader, the Inspector and the Preview’s selection, so they cannot drift; an unknown kind falls back to the region’s icon. <em>Test:</em> the kind-to-icon table is a pure value (<code>SegmentKindIconTests.swift</code>, not yet written); the drawing: not run.</li> <li><code>source.editor.segment-row-shows-its-facts-as-icons</code> — <strong>[PARTIAL]</strong> (#6482; owner 2026-11-11: icons in the segment list for language, direction, script and Unicode, and where an inherited value comes from. Code before: rows showed only the kind’s symbol in the nested Order list (<code>SegmentHierarchy.Level.symbolName</code>); direction laid text out and was never shown; the Inspector’s <code>InspectorLanguage</code> rows give value, origin and basis as text, from the engine’s <code>resolve_script</code>, <code>resolve_language</code>, <code>resolve_direction</code> with <code>LanguageResolution.level</code>. Built 2026-11-11, the first slice: <code>SegmentRowFactsView</code> after a row’s words in the Segments list: the count, a direction arrow, language and script capsules dimmed when inherited with a tooltip naming where from (“from its region”), and the reading’s state (a person glyph; a caution glyph with the confidence below 0.8; “no reading”); made once per list by <code>SegmentRowFacts.all</code>; a “Show in Rows” submenu in the pane’s view menu picks which, saved per window (<code>@SceneStorage("segments.rowFacts")</code>); <code>ReadingOrderList</code> only takes a <code>rowAccessory</code> closure. Not built: Unicode facts, the tooltip naming the parent by its number. Seen in its preview, not yet in the running app.) every segment row (<code>source.editor.segment-row-is-the-same-in-every-lens</code>) carries small icons for what is known of the segment: kind; script (ISO 15924 code); language (BCP 47 tag); direction and line progression; the Unicode facts of its shown reading (the scripts its characters are in, characters outside the declared script, private-use or MUFI characters, the normalisation form); certainty and damage marks; whether its text is tied, doubtful or untied (<code>source.editor.content-shows-its-tie-to-the-lines</code>); ground truth (<code>source.reading.ground-truth-is-a-reading</code>). An inherited value is drawn dimmed and its tooltip names where it came from (“Latin · from the page”, “right to left · from region 2”); a value set on the segment itself is drawn full. The icons come from one engine answer per page, not one call per row. Acceptance: a word in a Latin region of a Spanish page shows “la” dimmed with the tooltip naming the region. <em>Test:</em> <code>fichero/Tests/Unit/general/Models/SegmentsFilterTests.swift</code> (the first slice: <code>allMatchesEach</code>, <code>shownRoundTrips</code>, <code>factWords</code>); the icons from the engine answer are not yet tested. <em>First slice (owner 2026-11-11: as much as the list can show, words, characters and reading direction among it):</em> from what the page’s segments already carry, no new call: the kind’s icon; the counts (a region its lines, a line its words, a word its characters, each of its shown reading or its children); the direction as an arrow (→ ← ↓ ↑), dimmed when inherited from a parent (<code>SegmentStore.direction(of:)</code>); the language and script codes as small capsules, dimmed when inherited from a parent segment; the reading state: no reading, a person’s reading (the person glyph), a machine’s reading below its confidence floor (a caution glyph with the confidence), the teacher-line flag as today. A <strong>Show in Rows</strong> submenu of the pane’s view menu switches each fact on or off for the window, all on by default except the codes. Each fact’s tooltip says it in words (“7 words · 38 characters”, “right to left, from region 2”). One model (<code>SegmentRowFacts</code>) computes them for every lens.</li> </ul> <h3 id="engine-facts-not-yet-shown-audit-2026-11-11-6551">Engine facts not yet shown (audit 2026-11-11, #6551)</h3> <ul> <li><code>source.editor.facts-say-where-they-come-from</code> — <strong>[GAP]</strong> (#6551, #4938; Code: <code>Segment.language_meta</code>, <code>script_meta</code> and <code>direction_meta</code> carry source, status and level, and the cascade names the segment that answered (<code>LanguageResolution.segment_id</code>, 1911fa5d6); the list row only dims an inherited value) every place that shows a segment’s language, script or direction says where it came from in words on hover (“set by a person on region 2”, “detected from the letters”, “from the page”), from the engine’s own record, never re-derived in the app. <em>Test:</em> <code>SegmentFactSourcesTests.swift</code> (not yet written).</li> <li><code>source.reading.doubted-letters-are-tinted</code> — <strong>[GAP]</strong> (#6551, #5707; Code: a reading’s <code>char_confidences</code> is kept and never read by the app) the Reader and the Inspector tint the letters of a reading its reader doubted (below its confidence floor), so a person sees where to look; a reading with no per-letter confidence draws plain. <em>Test:</em> <code>ReadingLetterConfidenceTests.swift</code> (not yet written).</li> <li><code>source.reading.why-it-counts-is-its-record</code> — <strong>[GAP]</strong> (#6551; Code: <code>counting_basis</code> and <code>read_by</code> reach the app only as <code>ShownReadingLabel</code>’s one line) a reading’s Inspector box shows its record: who or what read it (<code>read_by</code>), why it counts or does not (<code>counting_basis</code>), and the run that made it, linked to Activity. <em>Test:</em> <code>InspectorReadingRecordTests.swift</code> (not yet written).</li> <li><code>source.pass.list-shows-ground-truth-rank-and-original</code> — <strong>[GAP]</strong> (#6551, #4947; Code: <code>PUT /api/passes/{id}/ground-truth</code> has no caller in the app) the page’s Making section lists every pass with its rank in the working-pass ranking, whether it is ground truth (a switch, the audited call), and its original file when it has one. <em>Test:</em> <code>InspectorMakingPassesTests.swift</code> (not yet written).</li> <li><code>source.reading.chains-and-runs-are-links</code> — <strong>[GAP]</strong> (#6551, #6492; Code: a reading’s <code>derived_from</code> and <code>corrects</code> ids and its run id are not shown) a reading says what it was derived from and what it corrects, each a link to that reading, and its run id opens the run in Activity. <em>Test:</em> <code>InspectorReadingChainTests.swift</code> (not yet written).</li> <li><code>source.segment.alto-line-types-are-shown</code> — <strong>[GAP]</strong> (#6551; Code: an ALTO line’s type survives only as <code>foreign["alto:tags"]</code>) an imported line type (heading, margin, interlinear) is the segment’s type, shown as its row icon and exported back. <em>Test:</em> <code>test_alto_line_types_round_trip.py</code> (not yet written).</li> <li><code>source.segment.history-says-it-was-merged-or-split</code> — <strong>[GAP]</strong> (#6551; Code: merged and split segments forward their old ids; History lists versions only) the segment’s History says when it was made by joining or splitting others, naming them, and a reference to an old id says where it went. <em>Test:</em> <code>SegmentForwardingHistoryTests.swift</code> (not yet written).</li> <li><code>source.segment.carried-facts-say-where-from</code> — <strong>[GAP]</strong> (#6551, #5165; Code: accepting a match carries readings and marks across; the segment does not show what came from where) a reading or mark carried from a matched segment says so on the segment, naming the match. <em>Test:</em> <code>CarriedFactsTests.swift</code> (not yet written).</li> <li><code>source.editor.layout-order-is-plainly-labelled</code> — <strong>[GAP]</strong> (#6482) the order’s name (“Layout Order”) is a visible heading with its picker, not a small subtitle menu, in the Reader’s Segments view and the Inspector’s Order tab, at the top like the renditions and ALWAYS there: with no named order it still reads “Layout Order” and its menu offers Create Named Order (the footer sentence and button are gone; what a layout order is lives in the tooltip, never in the menu); in Segments mode the Order list and the Reader’s lines are both visible together. <em>Test:</em> the heading is present when there is one order and when there are several (<code>ReadingOrderHeadingTests.swift</code>, not yet written).</li> <li><code>source.editor.empty-order-fills-the-pane</code> — <strong>[GAP]</strong> (#6482) with no reading order or no segments, the “No Reading Order” state is centred in the pane’s full height, the same height as a list with rows, so the pane does not jump when the first segment arrives. <em>Test:</em> not run: a UI check of the pane’s frame with zero and with some rows.</li> <li><code>source.editor.segment-verbs-are-the-same-everywhere</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-10) the same segment verbs are offered on a segment in the Order list, the Reader’s lines, the document Inspector and the Preview, by every route: a context menu, drag and drop, the keyboard and the menu bar (Edit › Segments), from ONE table (<code>LineVerbsTarget</code>), so no surface has a verb another lacks. The verbs: <strong>Set Kind / Direction / Mark as Text or Furniture</strong> (the attribute menu, <code>segment.update_many</code>), <strong>Move Into Region ▸</strong> (a submenu of the page’s regions; the drag onto a region row does the same; <code>segment.reparent</code>), <strong>Lift Out of Region</strong> (to the page), Merge (two or more lines; <code>segment.merge</code>), Split (<code>segment.split</code>), Delete, Correct This Line / Rename, Show in Preview, Move Up/Down/Start/End. A verb that cannot apply to the selection is absent, not greyed (the menu shows only what can be done). <em>Test:</em> the verb table per surface and selection is one pure value (<code>SegmentVerbsTableTests.swift</code>, not yet written); the same verb set from the menu, the keyboard and a drop is asserted by name.</li> <li><code>source.editor.order-list-drags-out-and-into-a-workflow</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-09: drag to the Desktop; run a workflow on a segment or a collection) rows are draggable: a drag to the Desktop or another app gives the selection’s text (a line) or a text file of the region’s lines in order; a drag onto a workflow (or its Run on Selection item) runs it on those segments, the same scope rule as <code>source.editor.run-the-next-step-on-the-selection</code>; a drag inside the list is still a reorder. <em>Test:</em> <code>OrderListDragTests.swift</code> (not yet written; the payload per selection, the workflow scope).</li> <li><code>source.editor.order-list-drag-reorders-and-reparents</code> — <strong>[PARTIAL]</strong> (#6577, #6476; owner 2026-11-13: dragging a line into another region stopped working, a regression of the drop built 2026-11-10, to be restored with its test run against the real drop; owner 2026-11-09: “drag and drop a line to put it into a region”. Code: <code>ReadingOrderList</code>’s <code>onMove</code> reorders the top level only; the nested rows (<code>SegmentOutlineRow</code>) take no drop; <code>segment.update</code> re-parents, <code>source.editor.regions-nest</code>, Step 1.12) in the nested Order list a row drags within its level (reorder, as today) and onto a region row or between a region’s lines (re-parent: the line becomes that region’s, placed where it dropped); a drop that cannot hold the dragged kind (a region into a line, a line onto itself) shows no drop target; one audited action (the re-parent and the place together) and one ⌘Z; the Segments list and the Preview follow. BUILT 2026-11-10 (owner confirmed a multi-line drop into Region 3 and from the segment list to the Inspector): the drop onto a region row, the whole row lit like the sidebar, through <code>OrderDrop.accepted</code> and <code>segment.reparent</code> (engine, audited, one undo; reading-order entries are not touched, so a reorder inside the list is still <code>reading_order.place</code>); what is still a GAP is the drop BETWEEN a region’s lines (placing it) and a drop on the Reader. The Reader shows only lines and no region rows (<code>ReaderLinesView</code>), so there is nothing to drop onto there: its line menu carries the same verbs instead (<code>source.editor.segment-verbs-are-the-same-everywhere</code>: Move Into Region ▸, Lift Out, Join, the attribute menu, from <code>SegmentVerbMenu</code>). <em>Test:</em> <code>OrderListReparentDropTests.swift</code> (written, passes; the drop target as a pure function of the dragged kind, the row and the position; the refusal cases). <em>Fix 2026-11-17 (#6577), not yet seen in the running app:</em> the break was 4c2fafd6a (2026-11-11, #6476), which moved the row’s drag from <code>.draggable</code> to <code>itemProvider</code> so a click on a row’s words selects it; the List’s <code>ForEach</code> also carried <code>.onMove</code>, and with the List owning the drag it took every in-list drag as an insertion between rows, so a drop ON a region row never reached <code>movable</code>’s <code>.dropDestination</code>. The <code>.onMove</code> is gone: a drop on a region row moves the lines in, a drop on another row takes its place (<code>reordered</code>), and ⌥⌘↑/↓ still move by key. No unit test can pin SwiftUI’s drag routing; to check by hand: drag a line onto a region row (it lights, the line moves in, one ⌘Z), onto a line row (it takes that place), and click a row’s words (it selects).</li> <li><code>source.editor.order-list-indents-with-tab</code> — <strong>[PARTIAL]</strong> (#6476, built 2026-11-11, not yet seen in the running app; owner 2026-11-11 work order: “Tab/Shift-Tab indent/outdent”) in the nested Order list (the Segments pane), Tab puts the selected rows into the row just above the first of them at its own level when that row can hold them (a line into the region above it: <code>OrderDrop.accepted</code>), and Shift-Tab takes them out of their parent into the parent’s own parent (a line out of its region to the page); each is the one audited reparent, one ⌘Z, the same as a drop on a region (<code>SegmentMover.run</code>). Where there is nowhere to go the key is not taken, so Tab still moves the focus; with the filter on it does nothing. <em>Test:</em> <code>OrderListIndentTests.swift</code>.</li> <li><code>source.editor.double-click-a-line-edits-it-in-the-inspector</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-11 work order: “double-click a line in the Inspector list or the Reader opens it for editing in the Inspector”. Code: a double-click on an Order-list row reveals it (<code>ReadingOrderList.reveal</code> → <code>WindowState.revealSegments</code>); from the Inspector’s own Order section the Inspector holds where it was (<code>LineRevealTests.aRevealFromTheInspectorsOrderTabLeavesTheInspectorWhereItWas</code>, ruled 2026-10-04), so this changes that ruling for the double-click only; Return renames in place) a double-click on a line in any Order list (the Inspector’s Order section, the Segments pane) or in the Reader’s Lines view selects the line for the window (<code>WindowState.pickInReader</code>), reveals it in a focused Preview, shows its Segment pane in the Inspector, and opens its counting reading in the Inspector’s editor (Edit…), the caret at the end; Esc leaves the editor, ⌘Return saves. A single click keeps today’s behaviour. Design: a token request on <code>WindowState</code> (segment id + count) that <code>SegmentInspectorView</code> takes once the line’s readings have loaded. <em>Test:</em> <code>LineRevealTests</code> (not yet written: a double-click asks the edit; the Inspector opens Edit… on the counting reading).</li> <li><code>source.editor.correct-this-line-shows-the-ink</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-09: “it opens an alert; the alert should show the source image and let us zoom in”. Code: <code>CorrectThisLineModifier</code> asked in a text-only alert; the line’s picture is <code>SegmentPictureService.picture</code> (the Reader’s row fetches it)) Correct This Line (the Reader’s rows, the Preview’s popover, the menu items) asks in a sheet that shows the line’s picture above the words: zoomed by the pinch, the zoom buttons and ⌘+ / ⌘-, between the line’s own size and six times it, scrolled when larger than the sheet; Return saves, Esc cancels. The Order list corrects in place (Return) and needs no sheet. <em>Test:</em> <code>CorrectLineZoomTests</code> (the zoom clamp), the existing <code>CorrectLineTests</code>.</li> <li><code>source.editor.preview-shades-the-order</code> — <strong>[GAP]</strong> (#6476; owner 2026-11-09: “isn’t the preview supposed to show our reading order with subtle variations in colour?”. Checked 2026-11-09: it does, by design: <code>RegionColours.tones</code> (spec <code>colour.reading-order-gradient</code>) draws each region in its hue and its lines from the lightest to full strength (light to dark, owner 2026-11-10) down to 0.7 along the order, the Preview, the Segments list’s swatches and the Reader’s rules all read it. The gap: it takes an optional <code>readingOrder</code> and NO caller passes one (<code>SegmentDisplay.swift:167</code>, <code>ReaderRegionRules.swift:20</code>, <code>ReadingOrderList.swift</code>, <code>SegmentsPaneView.swift:54</code> all call <code>tones(of:)</code>), so the shade follows the boxes’ own <code>boxIndex</code> order, not the order the person chose in the picker, and does not change when they pick another or reorder) the shown order’s sequence (the Order list’s <code>store.shown</code> entries, flattened by level) is passed as <code>readingOrder</code> to every <code>tones</code> call, so choosing a named order or moving a row re-shades the Preview and the lists; with no order chosen it stays as written. <em>Test:</em> <code>RegionColoursTests</code> (the existing gradient tests, plus a case that a given order changes the strengths), <code>PreviewShadesTheOrderTests.swift</code> (the plumbing, not yet written).</li> <li><code>source.editor.rotate-a-segment-as-one-action</code> — <strong>[GAP]</strong> (#6494; owner 2026-11-10: sideways text) Rotate Right, Rotate Left, Rotate 180 and Set Angle… on a selected region or line (Edit › Segments ▸, the context menus, the Preview tool bar) write the anchor’s existing <code>rotation</code> (degrees clockwise, <code>SourceAnchor.rotation</code>, engine <code>fichero-server/src/fichero_server/models/anchors.py</code>; the app already decodes it in <code>SourceAnchorValue</code> and ignores it) through ONE <code>segment.update</code> with <code>expected_version</code>, so one audit row and one ⌘Z per action, several selected segments one batch (<code>segment.update_many</code>), never a new action. Rotation turns the READING of the box, not its pixels: <code>rect</code>/<code>polygon</code> do not change. Offered only where it applies (a verb that cannot apply is absent).</li> <li><code>source.editor.rotated-segment-reads-upright</code> — <strong>[GAP]</strong> (#6494) a rotated segment is shown the right way up wherever its picture is cut: the Reader’s line row, Correct This Line and the compare rows crop the box and turn the crop by <code>rotation</code> so the writing is horizontal; the reader model is given the same upright crop (one shared crop function, no second path).</li> <li><code>source.editor.preview-draws-the-rotated-box</code> — <strong>[GAP]</strong> (#6494) the Preview draws a rotated segment’s box with a small arrow on its top edge showing which way is up; Set Angle shows the angle live while dragging, Escape cancels, release saves.</li> </ul> <h2 id="build-order">Build order</h2> <p>Written 2026-11-08 for #6413 and #6412 after the Fable review (<code>agent-work/status/briefs/segment-editor-review-2026-11-08.md</code>). For lane-ie, in order. The manager reads the steps before approval.</p> <h3 id="stage-1-crud-on-every-surface-no-mode-gate-nothing-lost">Stage 1 — CRUD on every surface, no mode gate, nothing lost</h3> <p>Order and cross-spec dependencies (Fable review 2026-11-08, fixes 6 and 13): 1.1 first; then 1.2 (the gate); then <code>source/image-preparation.md</code> Steps 1.4 and 1.5 (one box mapping in one place), which 1.1’s marquees, 1.4’s new shapes, 1.11’s Paint stroke and 1.14’s overlays all draw through; then 1.3, 1.5, 1.6. 1.8 rides on <code>ui/menus-and-commands.md</code> Step 1.1 (the selection-scoped start). 1.14’s Flip is <code>source/models-chains-and-projects.md</code> Step 3.1 (<code>CompareViewModel</code> has Side by Side, Overlay and Wipe today; Flip is that step’s). Engine-first steps run in parallel with the Swift ones: 1.12’s kind table, 1.13’s words, 1.11’s fit. RISKY BLIND IN SWIFT, needing the Air launch check or the owner’s eyes before they are called done: 1.7’s chrome move, 1.9 and 1.10’s ⌫ and ⌘A routing in the Reader, 1.12’s drag re-parent, 1.14’s draggable overlays, Paint’s stroke-to-rendition-frame mapping.</p> <h4 id="step-11-n-marquees-one-audit-row-one-undo-delete-deletes-the-segment-6412-6419">Step 1.1 — N marquees, one audit row, one undo; Delete deletes the segment (#6412, #6419)</h4> <ul> <li>Behaviours: <code>source.editor.n-marquees-one-audit-one-undo</code>, <code>source.editor.delete-deletes-the-segment</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, test_n_marquees_one_audit_row_6412.py (not yet written), test_preview_delete_deletes_the_segment_6419.py (not yet written), PreviewSegmentCrudTests.swift (not yet written)</li> <li>Size: S</li> </ul> <p>The regions route already lands segments (<code>segment.convert_and_edit</code>); this step changes the grain: ▶ over N marquees sends ONE create batch through the existing segment path (<code>segment.create_many</code>, chosen in words over a list-taking regions route), the batch placing its rows in the as-written order as a single create does, and the Preview re-reads the store once. Red test first: on base, N adds give N audit rows. Unverified and NOT claimed: loss on a page whose shown pass has a result artifact; reproduce on a scratch library before saying so. Delete (#6419, lane-ie): the Preview’s ⌫ and Delete on an artifact page go through <code>SegmentDeleter</code>, not <code>deleteRegions</code>; red test first. The Reader’s Lines mode is already right; its other surfaces take the same door in Step 1.9.</p> <ul> <li> <p>test (to write): <code>test_preview_delete_deletes_the_segment_6419.py</code> in fichero-server/tests/unit/api/ (two regions deleted from an artifact page are gone as segments, one audit row, one undo restores both)</p> </li> <li> <p>test (to write): <code>test_n_marquees_one_audit_row_6412.py</code> in fichero-server/tests/unit/api/ (three regions in one batch: three segment rows, one audit row, one undo removes three; a single region unchanged)</p> </li> </ul> <h4 id="step-12-the-gate-goes-edit-segments-and-the-same-doors-on-every-surface-6413">Step 1.2 — the gate goes; Edit › Segments ▸ and the same doors on every surface (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.no-mode-gate-selection-is-the-edit-state</code>, <code>source.editor.edit-segments-submenu-and-doors</code>, <code>source.editor.crud-one-action-each-every-door</code>, <code>source.editor.right-click-selects-first-double-click-edits</code></li> <li>Tests: fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, fichero/Tests/Unit/general/App/PageMenuTests.swift, fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, SegmentVerbsNeedNoModeTests.swift (not yet written), SegmentDoorsAgreeTests.swift (not yet written), PDFSegmentDoorsTests.swift (not yet written)</li> <li>Depends on: 1.1</li> <li>Size: M</li> </ul> <p>Swift only. Order: the guards at the sites named on the bullet go (the Fable review counts eleven <code>isEditingSegments</code> reads in <code>ZoomableImagePreviewMac+Regions.swift</code> alone; every one), the menu’s reason loses its mode clause; nudge after the gate is tested; Edit Segments becomes the Edit Shape tool-bar state; right-click selects first and double-click opens the edit, the popover becoming the edit’s text field; <code>SegmentMenuContent</code> moves under Edit › Segments ▸ and is rendered by the four context menus with the table’s icons and the proposed shortcuts, the uniqueness test run before any chord is kept.</p> <ul> <li>test (to write): <code>SegmentVerbsNeedNoModeTests.swift</code> in fichero/Tests/Unit/general/App/ (enabled state and reason from the selection count alone; Edit Shape is a tool, not a precondition)</li> <li>test (to write): <code>SegmentDoorsAgreeTests.swift</code> in fichero/Tests/Unit/general/App/ (one item table rendered by the submenu and every context menu; icons and shortcuts equal; no chord repeats another in the app)</li> <li>test (to write): <code>PDFSegmentDoorsTests.swift</code> in fichero/Tests/Unit/general/Views/Preview/ (the PDF page renders the same table on a box; New Region, Split, Join and Delete reach the same calls; nudge works with no gate)</li> </ul> <h4 id="step-13-select-all-segments-then-one-delete-from-the-inspector-and-the-segments-pane-the-readers-half-follows-in-19-and-110-6413">Step 1.3 — Select All Segments, then one Delete, from the Inspector and the Segments pane; the Reader’s half follows in 1.9 and 1.10 (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.select-all-then-one-delete</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionSelectAllTests.swift, fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, SelectAllThenDeleteTests.swift (not yet written)</li> <li>Depends on: 1.2</li> <li>Size: S</li> </ul> <p>Swift only: Select All Segments over the shared <code>RegionSelection</code> from the Inspector and the Segments pane here; the Reader’s half (⌘A selecting lines, ⌫ routing) lands with Steps 1.9 and 1.10, not with this step alone; Delete through <code>SegmentDeleter</code> as today, with the count on the item.</p> <ul> <li>test (to write): <code>SelectAllThenDeleteTests.swift</code> in fichero/Tests/Unit/general/Models/ (all the page’s segments selected from the Inspector; one delete plan with every id; one audit id; the refusal in words)</li> </ul> <h4 id="step-14-new-region-new-line-edit-shape-and-seeing-them-saved-6413-6181-6183">Step 1.4 — New Region, New Line, Edit Shape, and seeing them saved (#6413, #6181, #6183)</h4> <ul> <li>Behaviours: <code>source.editor.add-region-and-line-from-anywhere</code>, <code>source.editor.preview-crud</code>, <code>source.editor.make-new-in-the-preview</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, PreviewMakeNewSegmentTests.swift (not yet written), PreviewSegmentCrudTests.swift (not yet written)</li> <li>Depends on: 1.1, 1.2</li> <li>Size: M</li> </ul> <p>Also needs <code>source/image-preparation.md</code> Step 1.5 (the one mapping) for a shape drawn on a rendition. Swift on the engine’s existing actions: New Region and New Line as items and from the Inspector, the drawn shape through the same create, the handles under Edit Shape, the saved state read from the store.</p> <ul> <li>test (to write): <code>PreviewMakeNewSegmentTests.swift</code> and <code>PreviewSegmentCrudTests.swift</code> in fichero/Tests/Unit/general/Views/Source/ (the create call built from a menu press and from a drawn shape; the new segment selected; the store re-read; one undo)</li> </ul> <h4 id="step-15-the-hierarchy-in-the-inspector-and-the-segments-pane-up-to-the-page-down-to-the-children-selectable-with-the-verbs-6413-6415">Step 1.5 — the hierarchy in the Inspector and the Segments pane: up to the page, down to the children, selectable, with the verbs (#6413, #6415)</h4> <ul> <li>Behaviours: <code>source.editor.hierarchy-selectable-with-verbs</code>, <code>source.editor.inspector-lists-each-segment-once</code>, <code>source.editor.colour-by-region-shade-within-it</code>, <code>source.editor.hover-and-selection-keep-the-region-colour</code></li> <li>Tests: fichero/Tests/Unit/general/Models/InspectorPathTests.swift, fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, fichero/Tests/Unit/general/Models/ReadingOrderStoreTests.swift, fichero/Tests/Unit/general/Models/RegionColoursTests.swift, fichero/Tests/Unit/general/Models/BoxColourThroughTheStoreTests.swift, InspectorHierarchyTests.swift (not yet written)</li> <li>Depends on: 1.2</li> <li>Size: M</li> </ul> <p>Swift on the Segments store: the “Where it sits” section from <code>InspectorPath</code> and the children list, rows selectable into the shared selection, the item table on each row; Up in the Segments pane. First, the small fix (lane-ie): the second <code>ReadingOrderList</code> under the hierarchy and the Order mode’s duplicate nesting go, the reorder verbs move onto the tree’s rows, each segment listed once; reproduce in the app which of the two sources the owner saw before removing both. With #6419 (lane-ie): <code>RegionColours.tones</code> hashes the hue by the region’s id and kind and ramps the shade within each region along the page order; the legend’s words. The page row’s Ignore is <code>models-chains-and-projects.md</code> Step 3.5’s verb.</p> <ul> <li>test (to write): <code>InspectorHierarchyTests.swift</code> in fichero/Tests/Unit/general/Views/Inspector/ (the rows for a word, a line, a region and the page; a click’s selection; the parent’s children lit; the item table present on every row)</li> </ul> <h4 id="step-16-split-the-tool-the-item-the-chord-unsplit-as-its-undo-6413">Step 1.6 — Split: the tool, the item, the chord; unsplit as its undo (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.split-has-a-door</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, SplitDoorTests.swift (not yet written)</li> <li>Depends on: 1.2</li> <li>Size: S</li> </ul> <p>Engine none (<code>segment.split</code>, <code>segment.unsplit</code> exist). Swift: the Split tool on the Editing bar cutting at the click, Split… in the item table with <code>scissors</code>, ⌥⌘S run through the uniqueness test before it is kept.</p> <ul> <li>test (to write): <code>SplitDoorTests.swift</code> in fichero/Tests/Unit/general/Views/Source/ (the cut point to the split params for a line and a region; the item in the submenu and the four context menus; the chord unique)</li> </ul> <h4 id="step-17-two-bars-the-reader-bar-and-the-editing-bar-edit-segments-becomes-edit-shape-6413">Step 1.7 — two bars: the Reader bar and the Editing bar; Edit Segments becomes Edit Shape (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.two-bars-reader-and-editing</code></li> <li>Tests: fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, TwoBarsTests.swift (not yet written)</li> <li>Depends on: 1.2, 1.6</li> <li>Size: M</li> </ul> <p>Swift only, moving the existing controls: the head controls and the Reader toolbar’s navigation, zoom and Display menu become the Reader bar; the image tools, Edit Shape with its kind, Split and the markup row become the Editing bar with its show rule; the two Edit Segments toggles go.</p> <ul> <li>test (to write): <code>TwoBarsTests.swift</code> in fichero/Tests/Unit/general/Views/Shell/ (every control’s bar as a table; the Editing bar’s show rule; no Edit Segments control; the accessibility names)</li> </ul> <h4 id="step-18-run-the-next-step-on-this-selection-the-item-the-chord-the-same-scope-rule-6413">Step 1.8 — run the next step on this selection: the item, the chord, the same scope rule (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.run-the-next-step-on-this-selection</code></li> <li>Tests: fichero/Tests/Unit/general/App/PageMenuTests.swift, fichero/Tests/Unit/general/App/MenuTerminologyBoundaryTests.swift, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, RunNextStepItemTests.swift (not yet written)</li> <li>Depends on: 1.2</li> <li>Size: M</li> </ul> <p>Depends across specs on <code>ui/menus-and-commands.md</code> Step 1.1 (the selection-scoped start, #6411), which lands first: the step name from the page’s steps-done, the label from kind and count, Run Again ▸ from <code>redo_steps</code>, the item in Edit › Segments ▸, Project › Read › Reading ▸ and the context menus, ⌥⌘⏎ through the uniqueness test. Engine: the selection-scoped start takes the step to run, as the folder’s redo already does.</p> <ul> <li>test (to write): <code>RunNextStepItemTests.swift</code> in fichero/Tests/Unit/general/App/ (the next step from steps-done; the label per kind and count; the three disabled reasons; the scope and step passed to the start)</li> </ul> <h4 id="step-19-the-readers-line-rows-and-text-use-the-one-item-table-no-second-verb-set-6413">Step 1.9 — the Reader’s line rows and text use the one item table, no second verb set (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.reader-uses-the-one-item-table</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, fichero/Tests/Unit/general/App/PageMenuTests.swift, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, ReaderUsesTheOneItemTableTests.swift (not yet written)</li> <li>Depends on: 1.2, 1.5, 1.6</li> <li>Size: M</li> </ul> <p>Swift only, on the one table of Step 1.2: <code>ReaderLineRow</code>’s context menu and the focused Reader selection render <code>SegmentMenuContent</code>, with Correct This Line… and Create Named Order as its last rows; <code>LineVerbsTarget</code> adapts the Reader’s selection (rows, a region header, the lines a text run touches) onto the table’s target; New Line, Join, Split, Edit Shape and the hierarchy header as the bullet says; ⌫ routing kept. Nothing new in the engine.</p> <ul> <li>test (to write): <code>ReaderUsesTheOneItemTableTests.swift</code> in fichero/Tests/Unit/general/Views/Reader/ (the item list on a row equals the table plus two; a text run maps to its lines; the header row’s target is the region; ⌫ routes to rows only with no focused field)</li> </ul> <h4 id="step-110-select-all-means-the-focused-panes-things-never-the-sidebars-a-sidebar-selection-never-spans-libraries-6413">Step 1.10 — Select All means the focused pane’s things, never the sidebar’s; a sidebar selection never spans libraries (#6413)</h4> <ul> <li>Behaviours: <code>ui.select-all.focused-pane-and-its-meaning</code>, <code>sidebar.selection-never-spans-libraries</code></li> <li>Tests: fichero/Tests/Unit/general/App/SelectAllRoutingPolicyTests.swift, fichero/Tests/Unit/general/App/MenuShortcutBoundaryTests.swift, fichero/Tests/Unit/general/Views/Library/SelectAllVisibleSurfaceTests.swift, SidebarSelectionOneLibraryTests.swift (not yet written)</li> <li>Depends on: 1.9</li> <li>Size: S</li> </ul> <p>Swift only: the per-pane meaning as a table on <code>SelectAllRoutingPolicy</code>, the Reader’s route onto the shared selection, the sidebar’s refusal kept and tested again; the one-library rule on the sidebar’s selection set over <code>CrossLibraryRoute</code>.</p> <ul> <li>test (to write): <code>SidebarSelectionOneLibraryTests.swift</code> in fichero/Tests/Unit/general/Views/Sidebar/ (⌘-click into another library replaces; a range stops at the library; the sidebar refuses ⌘A with and without a rename field)</li> </ul> <h4 id="step-111-labelled-shape-tools-on-the-editing-bar-and-paint-that-fits-a-line-or-a-region-to-the-ink-6413">Step 1.11 — labelled shape tools on the Editing bar, and Paint that fits a line or a region to the ink (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.labelled-shape-tools</code>, <code>source.editor.paint-fits-a-shape</code></li> <li>Tests: fichero/Tests/Unit/general/Models/ShapeDrawingEscapeTests.swift, fichero/Tests/Unit/general/Models/ImportedPageDrawsItsBoxesTests.swift, test_paint_fits_a_shape.py (not yet written), LabelledShapeToolsTests.swift (not yet written), PaintToolTests.swift (not yet written)</li> <li>Depends on: 1.4, 1.7</li> <li>Size: M</li> </ul> <p>The design look is section 7 of <code>agent-work/status/briefs/segment-editor-review-2026-11-08.md</code>; the owner reads it before this step is approved. Also needs <code>source/image-preparation.md</code> Step 1.5: a stroke painted on a rendition is mapped to the photograph’s frame before the fit. Engine first: the fit as the pure runner function of the <code>refine-shapes</code> job kind, red then green on synthetic ink, then the <code>stroke</code> anchor kind on <code>segment.create</code> resolved by it at create time (no new field, no new route). Swift: the labelled tools replace the kind menu on the Editing bar, keys and cursor, the remembered tool; the Paint stroke, its width, the create call, the handles after.</p> <ul> <li>test (to write): <code>test_paint_fits_a_shape.py</code> in fichero-server/tests/unit/recipes/ (the five synthetic cases through the <code>refine-shapes</code> runner function; a <code>segment.create</code> with a <code>stroke</code> anchor stores the fitted outline and baseline as one audited row)</li> <li>test (to write): <code>LabelledShapeToolsTests.swift</code> and <code>PaintToolTests.swift</code> in fichero/Tests/Unit/general/Views/Preview/ (the tool table and keys; the remembered kind; the stroke’s call and width keys; handles shown after a fit)</li> </ul> <h4 id="step-112-regions-nest-a-drawn-segment-takes-the-smallest-containing-region-re-parent-by-drag-deleting-a-parent-asks-6413">Step 1.12 — regions nest; a drawn segment takes the smallest containing region; re-parent by drag; deleting a parent asks (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.regions-nest</code>, <code>source.editor.deleting-a-parent-asks</code></li> <li>Tests: fichero/Tests/Unit/general/Models/InspectorPathTests.swift, fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, test_regions_nest_6413.py (not yet written), test_deleting_a_parent_asks_6413.py (not yet written), HierarchyDragTests.swift (not yet written), DeleteParentChoiceTests.swift (not yet written)</li> <li>Depends on: 1.5</li> <li>Size: M</li> </ul> <p>Engine first: the parent-kind table and the cycle check on <code>segment.update</code>, the smallest-containing-region default on create, the two delete ways as one audited batch each. Swift: the drag in Step 1.5’s hierarchy, the parent set on a drawn or painted shape, the delete question. The hierarchy up to the page and down to the children is Step 1.5.</p> <ul> <li>test (to write): <code>test_regions_nest_6413.py</code> and <code>test_deleting_a_parent_asks_6413.py</code> in fichero-server/tests/unit/api/ (the kind table; the cycle refusal; the containing-region default; delete with children and lift as one undo each)</li> <li>test (to write): <code>HierarchyDragTests.swift</code> and <code>DeleteParentChoiceTests.swift</code> in fichero/Tests/Unit/general/Views/Inspector/ (the drag’s update call and refusals on the row; the question’s three ways and when it is not asked)</li> </ul> <h4 id="step-113-reading-orders-say-where-they-came-from-the-page-order-is-chosen-and-badged-and-feeds-the-reader-export-and-next-steps-6421">Step 1.13 — reading orders say where they came from; the page order is chosen and badged, and feeds the Reader, export and next steps (#6421)</h4> <ul> <li>Behaviours: <code>source.editor.orders.say-where-they-came-from</code>, <code>source.editor.orders.the-page-order-is-chosen-and-badged</code>, <code>source.editor.orders.a-secondary-order-can-be-deleted</code></li> <li>Tests: fichero-server/tests/unit/api/test_reading_orders.py, fichero/Tests/Unit/general/Models/ReadingOrderStoreTests.swift, test_orders_say_where_from_6421.py (not yet written), test_page_order_feeds_reader_export_next_steps_6421.py (not yet written)</li> <li>Depends on: 1.2</li> <li>Size: M</li> </ul> <p>For lane-onboard after #5727. Engine first: the words on <code>ReadingOrderRead</code> from its pass’s step, model and run; the page-order field and its choice as one audited action (the working pass’s as-written by default); the rule that Reader, export, neighbours and next steps read the page order, checked against <code>page_export.py</code>, <code>segment_readings.py</code>, <code>compare_readings.py</code> and the recipe runner. Swift: the words and the badges on the picker and the list head; Delete Order on the picker, the row and its context menu with the sentence. Engine: the two refusals on <code>reading_order.delete</code>. No new route.</p> <ul> <li>test (to write): <code>test_orders_say_where_from_6421.py</code> and <code>test_page_order_feeds_reader_export_next_steps_6421.py</code> in fichero-server/tests/unit/api/ (the words per provenance; the choice as one undo; every reader of the order reads the page order)</li> </ul> <h4 id="step-114-orders-seen-on-the-page-three-ways-combined-and-edited-on-the-overlay-6421">Step 1.14 — orders seen on the page three ways, combined, and edited on the overlay (#6421)</h4> <ul> <li>Behaviours: <code>source.editor.orders.seen-on-the-page-three-ways</code>, <code>source.editor.orders.combined-and-edited-on-the-page</code>, <code>source.editor.orders.a-flow-is-made-and-followed-across-pages</code></li> <li>Tests: fichero-server/tests/unit/api/test_reading_orders.py, fichero/Tests/Unit/general/Models/CompareViewTests.swift, test_combine_orders_6421.py (not yet written), OrdersSeenOnThePageTests.swift (not yet written), OrderOverlayEditTests.swift (not yet written)</li> <li>Depends on: 1.5, 1.13</li> <li>Size: M</li> </ul> <p>Also needs <code>source/models-chains-and-projects.md</code> Step 3.1 (the Flip mode) and <code>source/image-preparation.md</code> Step 1.5 (the mapped boxes). Engine: Combine Orders as one <code>reading_order.create</code> with its entries by the interleave or take-then rule. Swift: the numbered overlay on the mapped boxes (<code>prep.preview-draws-segments-on-the-selected-rendition</code>), the two-sided Compare component with orders as its sides in Side by Side, Overlay, Wipe and Flip, the overlay edits through the existing <code>reading_order.place</code> and <code>.renumber</code> and the one item table’s segment verbs.</p> <ul> <li>test (to write): <code>test_combine_orders_6421.py</code> in fichero-server/tests/unit/api/ (interleave and take-then; sources untouched; one undo)</li> <li>test (to write): <code>OrdersSeenOnThePageTests.swift</code> and <code>OrderOverlayEditTests.swift</code> in fichero/Tests/Unit/general/Views/Preview/ (the numbered overlay; the three modes and the flip with two orders; a dragged number’s place call; a renumber)</li> </ul> <h4 id="step-115-select-takes-you-there-one-reveal-from-every-surface-every-pane-scrolls-its-row-back-and-forward-on-the-windows-history-6413">Step 1.15 — select takes you there: one reveal from every surface, every pane scrolls its row, Back and Forward on the window’s history (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.select-takes-you-there-and-back</code></li> <li>Tests: fichero/Tests/Unit/general/Models/ContentViewRestoredSelectionTests.swift, fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, RevealAndBackTests.swift (not yet written)</li> <li>Depends on: 1.5, 1.9</li> <li>Size: S</li> </ul> <p>Swift only: the Segments pane’s and the Inspector rows’ single click call <code>WindowState.revealSegments</code>; each pane scrolls its row on <code>revealCount</code>; a reveal pushes an entry on the window’s existing navigation history with the view state and selection before it; Back and Forward are the existing items. No new engine call.</p> <ul> <li>test (to write): <code>RevealAndBackTests.swift</code> in fichero/Tests/Unit/general/Models/ (the one reveal from each surface; the scroll per pane; the history entry; Back and Forward restore state and selection)</li> </ul> <h4 id="step-116-group-make-new-from-selection-and-ungroup-one-audit-set-of-existing-actions-undone-whole-6413">Step 1.16 — Group / Make New From Selection and Ungroup: one audit set of existing actions, undone whole (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.group-makes-a-parent-from-the-selection</code></li> <li>Tests: fichero/Tests/Unit/general/Models/RegionSelectionTests.swift, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, test_group_is_one_audit_set_6413.py (not yet written), GroupUngroupTests.swift (not yet written)</li> <li>Depends on: 1.12</li> <li>Size: M</li> </ul> <p>Engine: <code>segment.update_many</code> takes <code>parent_segment_id</code> with the kind and cycle checks of Step 1.12 (no new action); the set undo already exists. Swift: the two items in the one table with icons and proposed chords, the two calls held as one ⌘Z step through the set undo, the hull from the selection’s shapes.</p> <ul> <li>test (to write): <code>test_group_is_one_audit_set_6413.py</code> in fichero-server/tests/unit/api/ (create + update_many undone whole; update_many’s parent checks; Ungroup’s lift + delete)</li> <li>test (to write): <code>GroupUngroupTests.swift</code> in fichero/Tests/Unit/general/Views/Inspector/ (the enabled rule; the calls; the set as one undo step)</li> </ul> <h4 id="step-117-reading-levels-the-levels-section-the-working-text-the-person-can-change-levels-side-by-side-and-switched-the-step-line-6429">Step 1.17 — reading levels: the Levels section, the working text the person can change, levels side by side and switched, the step line (#6429)</h4> <ul> <li>Behaviours: <code>source.editor.levels-section-and-working-text</code>, <code>source.editor.levels-shown-side-by-side-and-switched</code>, <code>source.editor.step-line-reads-and-writes-a-level</code></li> <li>Tests: fichero-server/tests/unit/api/test_reading_levels.py, fichero-server/tests/unit/api/test_compare_readers_5900.py, fichero/Tests/Unit/general/Models/CompareViewTests.swift, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, InspectorLevelsTests.swift (not yet written), ShownLevelTests.swift (not yet written), StepLineLevelsTests.swift (not yet written), test_working_text_is_read_by_later_steps_6429.py (not yet written), test_step_line_reads_and_writes_6429.py (not yet written)</li> <li>Depends on: 1.5, 1.14</li> <li>Size: L</li> </ul> <p>The look is <code>agent-work/status/briefs/readings-levels-look-2026-11-08.md</code> with the owner’s two answers. Engine first: the working-text setting (page over project, default as_written) as one audited field read by the later steps and the page’s constructed text; the compare answer’s <code>levels</code> sides (the one contract addition); the step line’s words from the job table and settings. Swift: the Levels section’s rows, badges and verbs on the existing readings list and editor; the shared <code>shownLevel</code>, the Reader bar menu and the chords through the uniqueness test; Compare with levels as sides; Make <level>… through the selection-scoped Normalise start.</p> <ul> <li>test (to write): <code>InspectorLevelsTests.swift</code> and <code>ShownLevelTests.swift</code> in fichero/Tests/Unit/general/Views/Inspector/ (the rows and badges from a readings list; the verbs’ calls; the shared level state and its fallback mark)</li> <li>test (to write): <code>test_working_text_is_read_by_later_steps_6429.py</code> and <code>test_step_line_reads_and_writes_6429.py</code> in fichero-server/tests/unit/api/ (the default and the page’s choice; a Names run reading the chosen level; the step line per job and setting; the compare sides by level)</li> </ul> <h4 id="step-118-the-agreement-heat-map-legend-and-non-colour-cue-one-map-on-the-preview-and-the-reader-choose-a-reading-from-the-popover-levels-as-sides-6438">Step 1.18 — the agreement heat map: legend and non-colour cue, one map on the Preview and the Reader, choose a reading from the popover, levels as sides (#6438)</h4> <ul> <li>Behaviours: <code>source.disagree.heat-map-legend-and-cue</code>, <code>source.disagree.one-map-on-preview-and-reader</code>, <code>source.disagree.choose-a-reading-from-the-popover</code>, <code>source.disagree.levels-as-sides</code>, <code>source.disagree.popover-lists-every-reader-and-the-lines-other-readings</code>, <code>source.disagree.agreement-is-character-similarity-defined-once-and-never-accuracy</code></li> <li>Tests: fichero/Tests/Unit/general/Models/ReadingDisagreementTests.swift, fichero/Tests/Unit/general/Models/DisagreementWiringTests.swift, fichero/Tests/Unit/general/Models/CompareViewTests.swift, fichero-server/tests/unit/api/test_where_the_readers_disagree_5665.py, fichero-server/tests/unit/api/test_correct_a_line.py, DisagreementLegendTests.swift (not yet written), AgreementLayerSharedStateTests.swift (not yet written), DisagreementPopoverVerbsTests.swift (not yet written), CompareLevelsTintTests.swift (not yet written)</li> <li>Depends on: 1.4, 1.17</li> <li>Size: M</li> </ul> <p>The behaviours live in <code>readings-and-apparatus.md</code> (APPROVED, no Build order of its own), under “Where the readers disagree”; this step is their home, as 1.17 is for the levels. Owner 2026-11-08: NOT in the dev build. No engine change: the map is <code>GET /api/documents/{page_id}/disagreement</code> as built (<code>source.disagree.route</code>), the pick is the existing correction (<code>representation.create</code>) or the existing choice route, and the level sides ride Step 1.17’s compare selector. Swift only: the legend and cue on <code>DisagreementTint</code>’s three states, the Preview overlay over the word-box layer from the one store, the window’s Agreement flag with its three doors, the popover’s two verbs, and the tint over the compare rows.</p> <ul> <li>test (to write): <code>test_disagreement_lists_absent_readers_6451.py</code> in fichero-server/tests/unit/api/ (red first: the absent list per line with its why, N from the line, agreement unchanged) and <code>DisagreementPopoverEveryReaderTests.swift</code> in fichero/Tests/Unit/general/Models/ (the rows from the two answers, one verb Make This Count); amended 2026-11-08 21:25 for #6451: the popover’s rows come from the disagreement answer (compared readers and the absent list) and the segment’s readings list (the other readings), engine first with the failing test; and (manager 21:35) agreement defined once as 1 − d / L per reader, the line’s mean, the page’s length-weighted mean, the word share kept beneath, the definition one tap away, the CER against a corrected text beside it where one exists, never accuracy (<code>test_agreement_is_defined_once_6451.py</code>, <code>AgreementDefinitionTests.swift</code>, both to write)</li> <li>test (to write): <code>DisagreementLegendTests.swift</code>, <code>AgreementLayerSharedStateTests.swift</code> and <code>DisagreementPopoverVerbsTests.swift</code> in fichero/Tests/Unit/general/Models/ (the legend’s words and the cue per tint; one flag three doors, both surfaces and the selection shared; the text composed for Use This Word and the one call per verb)</li> <li>test (to write): <code>CompareLevelsTintTests.swift</code> in fichero/Tests/Unit/general/Models/ (the tint and cue from compare rows with level sides; two sides never red)</li> </ul> <h4 id="step-119-mark-unclear-lost-and-supplied-on-a-stretch-from-the-reader-one-existing-action-with-a-span-drawn-everywhere-u-through-the-uniqueness-test-6451">Step 1.19 — Mark Unclear, Lost and Supplied on a stretch from the Reader, one existing action with a span, drawn everywhere, ⇧⌘U through the uniqueness test (#6451)</h4> <ul> <li>Behaviours: <code>source.editor.mark-a-stretch-unclear-from-the-reader</code></li> <li>Tests: fichero-server/tests/unit/api/test_editorial_facts.py, fichero/Tests/Unit/general/Views/Shell/MenuShortcutUniquenessTests.swift, ReaderMarkUnclearTests.swift (not yet written), test_editorial_record_a_stretch_6451.py (not yet written)</li> <li>Depends on: 1.4, 1.17</li> <li>Size: S</li> </ul> <p>Owner 2026-11-08 21:25: improve the spec, then update the code. Engine first: a span inside the reading accepted and out of range refused in words, withdraw as the undo (the action exists; the test pins the span). Swift: the selection to code points per line through the line map, one request per line in one audit set, the Edit › Mark ▸ row in the command table (Step 2.1 of <code>ui/menus-and-commands.md</code>), ⇧⌘U through <code>MenuShortcutUniquenessTests</code>, the signs drawn in the Lines row and the Preview’s inline text as the Inspector draws them. Review note 2026-11-08 23:15: the mark’s <code>representation_id</code> is the reading SHOWN where the selection was made (the shown level’s counting reading, <code>shownLevel</code>), as facts are per reading; the Inspector’s Certainty and Damage section lists facts per reading with the level named. Not in the dev build.</p> <ul> <li>test (to write): <code>ReaderMarkUnclearTests.swift</code> in fichero/Tests/Unit/general/Models/ (the selection to code points, one request per line, the three kinds’ spans, the chord)</li> <li>test (to write): <code>test_editorial_record_a_stretch_6451.py</code> in fichero-server/tests/unit/api/ (a span inside the reading; out of range refused; withdraw undoes)</li> </ul> <h4 id="step-120-the-shown-reading-is-the-counting-one-and-says-so-the-rule-stated-from-the-code-one-label-and-switcher-on-every-line-the-live-link-from-the-reader-to-the-source-pane-6451">Step 1.20 — the shown reading is the counting one and says so: the rule stated from the code, one label and switcher on every line, the live link from the Reader to the source pane (#6451)</h4> <ul> <li>Behaviours: <code>source.editor.the-shown-reading-is-the-counting-one-and-says-so</code>, <code>source.editor.live-link-from-the-reader-to-the-source-pane</code>, <code>source.editor.live-link-carries-a-set-of-lines</code></li> <li>Tests: fichero-server/tests/unit/models/test_counting_and_working_pass.py, fichero-server/tests/unit/api/test_reading_levels.py, fichero/Tests/Unit/general/Models/DisagreementWiringTests.swift, ShownReadingLabelTests.swift (not yet written), test_shown_text_is_the_counting_answer_6451.py (not yet written), ReaderToSourceLiveLinkTests.swift (not yet written)</li> <li>Depends on: 1.17, 1.18</li> <li>Size: M</li> </ul> <p>Owner 2026-11-08 21:25 and the manager’s addition 21:30. Engine first: the segment list’s text is the counting answer under the stated rule, and carries the basis and the maker so the label needs no second request (<code>counting_readings</code> already works it out; the list row gains <code>counting_basis</code>, <code>counting_level</code> and <code>read_by</code>, the one contract addition, named here); the none-counts case names the newest person’s reading for the label. Swift: ONE row model for the label, the switcher, the Inspector’s Text section, the Levels section and the popover; the label and switcher on the Preview’s inline text, the Lines row, the Content lens and the compare and disagreement line heads; the lenses that do not post on <code>.readerTextSelection</code> post, the disagreement store’s selected word becomes the focused selection; the Preview pins the label at the lit line. None counts: the newest person’s reading labelled “N readings, none chosen” (owner 2026-11-08 21:50, DECIDED). Not in the dev build.</p> <ul> <li>test (to write): <code>ShownReadingLabelTests.swift</code> and <code>ReaderToSourceLiveLinkTests.swift</code> in fichero/Tests/Unit/general/Models/ (the label per basis, the switcher’s rows and pick, each lens publishing on the two seams, the label following)</li> <li>test (to write): <code>test_shown_text_is_the_counting_answer_6451.py</code> in fichero-server/tests/unit/api/ (the list’s text per rule, the basis and maker on the row, none counts)</li> </ul> <h4 id="step-121-the-pane-title-says-what-is-showing-when-there-is-room-the-content-view-shows-its-tie-to-the-lines-and-a-click-lights-the-line-6458">Step 1.21 — the pane title says what is showing when there is room; the Content view shows its tie to the lines and a click lights the line (#6458)</h4> <ul> <li>Behaviours: <code>source.editor.pane-title-says-what-is-showing</code>, <code>source.editor.content-shows-its-tie-to-the-lines</code>, <code>source.editor.page-level-reading-of-any-level-is-tied-automatically-then-by-hand</code>, <code>source.editor.a-reading-records-who-made-it</code></li> <li>Tests: fichero-server/tests/unit/check/test_tie_text_to_lines.py, fichero/Tests/Unit/general/Models/DisagreementWiringTests.swift, PaneTitleSaysWhatIsShowingTests.swift (written, not run), ContentTieMarksTests.swift (not yet written), test_any_page_level_reading_is_tied_6458.py (not yet written), TieToLinesVerbsTests.swift (not yet written), test_a_reading_records_who_made_it_6458.py (not yet written)</li> <li>Depends on: 1.20, 3.7 of source/models-chains-and-projects.md</li> <li>Size: M</li> </ul> <p>Owner 2026-11-08 22:05, 21:46 and 22:15, spec first then code. Engine first for the two tie bullets: <code>after_page_reading</code> for every kind and level, the region unit for a translation, the row fields on every writer, the set undo (red tests first). Swift for the rest: the title’s three forms from the row model Step 1.20 builds and the shared <code>shownLevel</code>, through the pane head’s existing <code>ViewThatFits</code>; the margin marks from the Content view’s spans and the tie figures the Inspector’s glyph already reads (Step 3.7), the Untied block and the head line reused, the click on the two seams of #6455. Defaults taken without a question: glyphs only in the margin, no line numbers; marks at every width. Not in the dev build.</p> <ul> <li>test (to write): <code>PaneTitleSaysWhatIsShowingTests.swift</code> and <code>ContentTieMarksTests.swift</code> in fichero/Tests/Unit/general/Models/ (the three title forms and the summary rule; the glyph per span, the page-only state, the click publishing, the level rules)</li> </ul> <h4 id="step-122-run-a-workflow-on-a-piece-of-content-and-on-the-latest-the-step-reading-the-chosen-content-the-pages-content-listed-newest-first-in-the-pane-6460-6461">Step 1.22 — run a workflow on a piece of content and on the latest, the step reading the chosen content, the page’s content listed newest first in the pane (#6460, #6461)</h4> <ul> <li>Behaviours: <code>source.editor.run-a-workflow-on-content-and-on-the-latest</code>, <code>source.editor.content-listed-newest-first-in-the-pane</code></li> <li>Tests: fichero-server/tests/unit/api/test_reading_levels.py, fichero/Tests/Unit/general/App/RunAndChatMenuTests.swift, test_workflow_runs_on_a_reading_6460.py (not yet written), test_content_listed_newest_first_6460.py (not yet written), RunWorkflowOnContentMenuTests.swift (not yet written), ContentVersionsStripTests.swift (not yet written)</li> <li>Depends on: 1.20, 1.21</li> <li>Size: M</li> </ul> <p>Owner 2026-11-08 22:25 and 22:36, spec first then code. Engine first: <code>SelectionKind.readings</code> (the one contract addition) resolved and said, the latest resolved at run time and recorded by id, a step reading its input reading’s text and writing its output derived from it with the model and step on the row, the two lists ordered newest first (red tests first). Swift: the one Run Workflow ▸ component on the reading in its three homes and the command-table row (Step 2.1 of <code>ui/menus-and-commands.md</code>), the one row model behind the Content tab and the Versions strip. Defaults noted (strip collapsed, one row per run, relative time). Not in the dev build.</p> <ul> <li>test (to write): <code>test_workflow_runs_on_a_reading_6460.py</code> and <code>test_content_listed_newest_first_6460.py</code> in fichero-server/tests/unit/api/ (the readings target, the latest, the input and the derived output; the orders)</li> <li>test (to write): <code>RunWorkflowOnContentMenuTests.swift</code> and <code>ContentVersionsStripTests.swift</code> in fichero/Tests/Unit/general/Models/ (the three homes, the scope sentence; the strip and the list)</li> </ul> <h4 id="step-123-compare-2-to-4-readings-in-reader-content-with-the-lines-picture-per-row-edit-any-of-them-in-line-through-the-one-editor-6462">Step 1.23 — compare 2 to 4 readings in Reader › Content with the line’s picture per row, edit any of them in line through the one editor (#6462)</h4> <ul> <li>Behaviours: <code>source.editor.compare-two-to-four-readings-with-the-line-picture-and-edit-in-line</code></li> <li>Tests: fichero/Tests/Unit/general/Models/CompareViewTests.swift, fichero-server/tests/unit/api/test_compare_readers_5900.py, CompareInLineEditTests.swift</li> <li>Depends on: 1.17, 1.18, 1.20, 1.22</li> <li>Size: M</li> </ul> <p>Owner 2026-11-08 22:40, spec first then code (the Compare area, lane-onboard). Swift only: the compare answer already carries the picture and every reading’s id; <code>ReaderLineRow</code> is the editor; the lens title’s Compare ▸ picks from the newest-first list; the live link’s two seams. No engine change. Not in the dev build.</p> <ul> <li>test: <code>CompareInLineEditTests.swift</code> in fichero/Tests/Unit/general/Models/ (the 2 to 4 rule, the picture per row, the one save path with derived_from and level, the post on the seams)</li> </ul> <h4 id="step-124-parallel-text-source-levels-line-by-line-beside-prose-translations-each-clause-aligned-to-its-line-range-both-sides-and-the-preview-lit-together-6463">Step 1.24 — parallel text: source levels line by line beside prose translations, each clause aligned to its line range, both sides and the Preview lit together (#6463)</h4> <ul> <li>Behaviours: <code>source.editor.parallel-text-view</code>, <code>source.editor.translation-aligned-by-clause-to-line-ranges</code>, <code>source.editor.parallel-text-lights-both-sides-and-the-preview</code></li> <li>Tests: fichero/Tests/Unit/general/Models/CompareViewTests.swift, fichero/Tests/Unit/general/Views/Preview/ReaderPreviewLinkingTests.swift, fichero-server/tests/unit/check/test_tie_text_to_lines.py, ParallelTextViewTests.swift (not yet written), test_translation_aligned_by_clause_6463.py (not yet written), ParallelTextLiveLinkTests.swift (not yet written)</li> <li>Depends on: 1.17, 1.21, 1.22, 1.23</li> <li>Size: L</li> </ul> <p>Owner 2026-11-08 22:45, the flagship example; spec first then code. Engine first: the <code>reading_alignments</code> rows (the one new store, minimal) and their read route, the clause split from the NLP pass, the alignment run through the tie job’s chooser with the “translation clause” threshold row, the region fallback, the set undo, re-align on edit, the rows after a segment change (red tests first on the Ann sample page). Swift: Parallel Text as a Compare mode with prose columns, the column heads from the one row model, the in-line editor reused, the two seams for both directions. Export is a hook only, specified in <code>export/open-standards-profile.md</code>. Defaults taken without a question: clauses at the NLP pass’s sentence and clause boundaries; one to three translation columns; the region as the fallback anchor. Not in the dev build.</p> <ul> <li>test (to write): <code>test_translation_aligned_by_clause_6463.py</code> in fichero-server/tests/unit/check/ (the spans, the ranges and scores, the fallback, the set undo, re-align, a split)</li> <li>test (to write): <code>ParallelTextViewTests.swift</code> and <code>ParallelTextLiveLinkTests.swift</code> in fichero/Tests/Unit/general/Models/ (the sides and labels, the rule of three; clause to lines and back, the union)</li> </ul> <h4 id="step-125-the-order-list-edits-like-finder-rename-move-menus-drag-selection-that-follows-6476">Step 1.25 — the Order list edits like Finder: rename, move, menus, drag, selection that follows (#6476)</h4> <ul> <li>Behaviours: <code>source.editor.order-list-edits-like-finder</code>, <code>source.editor.order-list-selection-shows-everywhere</code>, <code>source.editor.order-list-moves-with-command-arrows</code>, <code>source.editor.order-list-context-menu-and-menu-commands</code>, <code>source.editor.order-list-drags-out-and-into-a-workflow</code>, <code>source.editor.order-list-drag-reorders-and-reparents</code>, <code>source.editor.correct-this-line-shows-the-ink</code>, <code>source.editor.preview-shades-the-order</code>, <code>source.editor.preview-has-three-modes</code>, <code>source.editor.layout-order-is-plainly-labelled</code>, <code>source.editor.empty-order-fills-the-pane</code>, <code>source.editor.toolbar-follows-the-mode</code>, <code>source.editor.split-and-edit-points-are-audited</code>, <code>source.editor.renditions-sit-with-the-flip-arrows</code>, <code>source.editor.display-menu-has-order-switches</code>, <code>source.editor.selection-is-shared-without-a-preview</code>, <code>source.editor.top-path-names-the-selection</code>, <code>source.editor.segment-verbs-are-the-same-everywhere</code>, <code>source.editor.reader-shows-versions-of-a-segment-on-request</code>, <code>source.editor.reader-line-discloses-its-versions</code>, <code>source.editor.kind-has-its-own-icon</code></li> <li>Tests: fichero/Tests/Unit/general/Models/ReadingOrderMoveTests.swift, OrderRenameTests.swift, OrderListSelectionTests.swift, OrderListMoveKeysTests.swift, OrderListMenuTests.swift, OrderListDragTests.swift, PreviewShadesTheOrderTests.swift (not yet written), test_segment_name_6476.py (not yet written)</li> <li>Depends on: 1.5, 1.9, 1.15</li> <li>Size: L</li> </ul> <p>Owner 2026-11-09, in order, each its own commit and test: (a) Return renames, double-click reveals, a click selects only (line text through <code>CorrectLine</code>; the region name needs the engine’s optional segment name, one red test first); (b) ⌘↑/⌘↓ move; (c) the context menu from the one item table, then the menu-bar commands; (d) selection both ways with the Segments list and the Preview; (e) drag out and drag onto a workflow; (f) check the Preview’s order shading. Pure functions (the edit state, the move target, the payload) carry the tests; what only the window can show is marked “not run” for the owner’s check in Xcode.</p> <h4 id="step-126-rotation-of-sideways-text-rotate-a-region-or-line-as-one-audited-action-read-and-drawn-upright-6494">Step 1.26 — rotation of sideways text: rotate a region or line as one audited action, read and drawn upright (#6494)</h4> <ul> <li>Behaviours: <code>source.editor.rotate-a-segment-as-one-action</code>, <code>source.editor.rotated-segment-reads-upright</code>, <code>source.editor.preview-draws-the-rotated-box</code></li> <li>Tests: SegmentRotationTests.swift (not yet written), UprightCropTests.swift (not yet written), test_segment_rotation_6494.py (not yet written)</li> <li>Depends on: 1.2, 1.9</li> <li>Size: M</li> </ul> <p>Engine first: confirm <code>segment.update</code> / <code>update_many</code> accept an anchor whose only change is <code>rotation</code> (normalised to 0 ≤ r < 360), one audit row, undo by <code>restore_version</code>; one red test. App: <code>SegmentRotation</code> (pure: right/left/180/set, normalise), the four items in the one <code>SegmentVerbMenu</code>, then the shared upright crop used by <code>ReaderLinesView</code>, <code>CorrectLine</code> and the compare rows, last the Preview box and arrow. Each its own commit. Test list for the owner after each commit: (1) rotate a line right, one ⌘Z undoes it; (2) three lines selected, one rotate, one ⌘Z; (3) the Reader row shows the writing upright; (4) the Preview box shows the up arrow.</p> <h4 id="step-127-one-segment-row-in-every-lens-picture-hierarchy-every-reading-indented-and-editable-6492">Step 1.27 — one segment row in every lens: picture, hierarchy, every reading indented and editable (#6492)</h4> <ul> <li>Behaviours: <code>source.editor.segment-row-is-the-same-in-every-lens</code>, <code>source.editor.segment-row-carries-the-shown-reading-facts</code>, <code>source.editor.segments-list-starts-at-the-page-with-its-orders</code></li> <li>Tests: SegmentRowModelTests.swift (not yet written), fichero/Tests/Unit/general/Views/Reader/ReaderLinesTests.swift</li> <li>Depends on: 1.20, 1.23</li> <li>Size: M</li> </ul> <p>One <code>SegmentRowModel</code> in Models (picture, shown reading, <code>ReadingTree</code>), drawn by the Reader’s Lines and Content views, the Segments pane’s List, Strip and Grid, the Inspector’s children and the Order list; each change updates its one row. Each surface its own commit, each seen in the running app.</p> <h4 id="step-128-the-segments-facts-as-icons-inherited-values-saying-where-they-came-from-6482">Step 1.28 — the segment’s facts as icons, inherited values saying where they came from (#6482)</h4> <ul> <li>Behaviours: <code>source.editor.segment-row-shows-its-facts-as-icons</code></li> <li>Tests: fichero/Tests/Unit/general/Models/SegmentsFilterTests.swift</li> <li>Depends on: 1.27</li> <li>Size: M</li> </ul> <p>The icons from the page’s one facts answer on the row of 1.27; inherited values dimmed, their source in the tooltip. The parent-segment walk is the engine’s <code>source.lang.cascade-walks-the-parent-segments</code> (#4938); until it lands the icons show the levels the engine already reports.</p> <h4 id="step-129-the-segments-pane-filters-a-bar-at-the-bottom-the-same-rule-in-every-lens-6476">Step 1.29 — the Segments pane filters: a bar at the bottom, the same rule in every lens (#6476)</h4> <ul> <li>Behaviours: <code>source.editor.segments-list-has-a-filter-bar</code></li> <li>Tests: fichero/Tests/Unit/general/Models/SegmentsFilterTests.swift</li> <li>Depends on: 1.27</li> <li>Size: M</li> </ul> <p>One pure <code>SegmentsFilter</code> (query and facets in, the matching ids and their ancestors out), then the bar under the list, then the strip and grid. The row facts it filters on are <code>SegmentRowFacts</code> (1.28).</p> <h4 id="step-130-the-inspectors-segment-pane-in-groups-picture-first-empty-groups-hidden-one-add-menu-6413">Step 1.30 — the Inspector’s segment pane in groups: picture first, empty groups hidden, one Add menu (#6413)</h4> <ul> <li>Behaviours: <code>source.editor.inspector-segment-pane-is-laid-out-in-groups</code></li> <li>Tests: InspectorSegmentLayoutTests.swift (not yet written)</li> <li>Depends on: 1.28</li> <li>Size: M</li> </ul> <p>A pure <code>InspectorSegmentLayout</code> decides which groups show and in what order; the view draws them in the grouped form style. <code>SegmentInspectorView</code> is over its line cap, so the groups move out to their own files as they are touched.</p> <h4 id="step-131-the-segments-stay-true-list-order-tab-and-drawing-refresh-on-the-pages-event-a-drawn-region-is-always-made-the-drag-into-a-region-restored-6574-6580-6577">Step 1.31 — the segments stay true: list, Order tab and drawing refresh on the page’s event; a drawn region is always made; the drag into a region restored (#6574, #6580, #6577)</h4> <ul> <li>Behaviours: <code>source.editor.segments-follow-the-page-change-event</code>, <code>source.editor.drawing-a-region-always-makes-it</code></li> <li>Tests: SegmentsFollowThePageTests.swift (not yet written), test_a_runs_pass_raises_the_page_event.py (not yet written), RegionDrawTests.swift (not yet written)</li> <li>Depends on: 1.25</li> <li>Size: M</li> </ul> <p>Bug fixes first (owner 2026-11-13): the drag-into-a-region regression (#6577, <code>source.editor.order-list-drag-reorders-and-reparents</code>, which stays in Step 1.25) is found by running the existing <code>OrderListReparentDropTests.swift</code> against the real drop; then the event refresh, then the draw.</p> <h4 id="step-132-one-order-control-on-every-surface-one-default-near-duplicates-folded-titles-with-source-and-date-6576-6421">Step 1.32 — one order control on every surface, one default, near-duplicates folded, titles with source and date (#6576, #6421)</h4> <ul> <li>Behaviours: <code>source.editor.orders.one-control-on-every-surface</code>, <code>source.editor.orders.one-default-not-near-duplicates</code></li> <li>Tests: OrderControlEverywhereTests.swift (not yet written), test_orders_same_as.py (not yet written), ReadingOrderPickerDefaultTests.swift (not yet written)</li> <li>Depends on: 1.13, 1.31</li> <li>Size: M</li> </ul> <p>Engine first (<code>same_as</code> on the list answer; the title with source and date on <code>ReadingOrderRead</code>), then the picker on the Source bar, the Segments head and the Reader’s bar. The combine of two or more orders, named and chosen, is Step 1.14 as re-scoped 2026-11-13; <code>ui/panes-workspaces.md</code>’s build order (Stage 3) orders it after this step.</p> <h2 id="open-questions">Open questions</h2> <ol> <li>The proposed chords (⌥⌘A outside the Reader, ⌥⌘N, ⌥⇧⌘N, Edit Shape’s free chord, Split’s ⌥⌘S, Run next step’s ⌥⌘⏎) stand only if <code>MenuShortcutUniquenessTests</code> and the system-chord audit accept them; a collision picks another chord, never a second meaning for one.</li> <li>Whether Edit Shape stays a tool-bar state or becomes handles that appear on any single selection with no tool at all (recommended later, once a drag on a selected shape is told apart from a pan).</li> </ol> </article> </div> <script>var target=document.getElementById(location.hash.slice(1));target&&target.name&&(target.checked=target.name.startsWith("__tabbed_"))</script> </div> <button type="button" class="md-top md-icon" data-md-component="top" hidden> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M13 20h-2V8l-5.5 5.5-1.42-1.42L12 4.16l7.92 7.92-1.42 1.42L13 8z"/></svg> Back to top </button> </main> <footer class="md-footer"> <nav class="md-footer__inner md-grid" aria-label="Footer" > <a href="../segment-editor/" class="md-footer__link md-footer__link--prev" aria-label="Previous: Segment Editor"> <div class="md-footer__button md-icon"> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20 11v2H8l5.5 5.5-1.42 1.42L4.16 12l7.92-7.92L13.5 5.5 8 11z"/></svg> </div> <div class="md-footer__title"> <span class="md-footer__direction"> Previous </span> <div class="md-ellipsis"> Segment Editor </div> </div> </a> <a href="../../ui/segment-editor/" class="md-footer__link md-footer__link--next" aria-label="Next: Segment Editor Tools (Source pane & lines)"> <div class="md-footer__title"> <span class="md-footer__direction"> Next </span> <div class="md-ellipsis"> Segment Editor Tools (Source pane & lines) </div> </div> <div class="md-footer__button md-icon"> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M4 11v2h12l-5.5 5.5 1.42 1.42L19.84 12l-7.92-7.92L10.5 5.5 16 11z"/></svg> </div> </a> </nav> <div class="md-footer-meta md-typeset"> <div class="md-footer-meta__inner md-grid"> <div class="md-copyright"> <div class="md-copyright__highlight"> Fichero is vibe coded. Creative Direction by <a href="https://tubb.ca">Daniel Tubb</a>. </div> Made with <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener"> Material for MkDocs </a> </div> </div> </div> </footer> </div> <div class="md-dialog" data-md-component="dialog"> <div class="md-dialog__inner md-typeset"></div> </div> <script id="__config" type="application/json">{"annotate": null, "base": "../../../..", "features": ["navigation.tabs", "navigation.sections", "navigation.top", "navigation.indexes", "navigation.footer", "search.suggest", "search.highlight", "content.code.copy", "toc.follow"], "search": "../../../../assets/javascripts/workers/search.2c215733.min.js", "tags": null, "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}, "version": null}</script> <script src="../../../../assets/javascripts/bundle.79ae519e.min.js"></script> </body> </html>