Collapsible lanes — frontmatter-backed slim strips outside the width division

A lane folds to a fixed slim vertical strip carrying its glyph, its card-count
badge and its title turned on its side, and the strip is deliberately not part
of the window's division: the expanded lanes' units divide what is left once
each folded strip's fixed width has come off the top, so folding a lane is a
re-divide trigger of the Show/Hide Trash family — the window never moves and
the siblings grow into what the lane gave up.

The state is a first-class lane frontmatter key, `collapsed: true`, and
document state exactly as `width` is: the files are the board, so an agent
folds a lane by writing one key. Absent means expanded, expanding removes the
key rather than writing `false` (the remove-at-default family beside a
one-unit `width`, the empty rename's `title` and the None well's
`background`), and the lane's `width` rides along untouched so expanding
restores the lane the user had. The read is `width`'s leniency one type over —
a boolean scalar or a quoted boolean word reads as itself, everything else has
no reading at all and renders as expanded, bytes preserved either way.

Toggling is the header's always-visible collapse chevron, the lane context
menu's single Collapse Lane / Expand Lane row, and a plain click anywhere on
the strip; a modified click on the strip stays the ordinary selection grammar,
so a folded lane is still selectable by pointer. The title reads bottom-up and
is justified to the top of the room below the strip's chrome (owner ruling
2026-08-08), truncating against the strip's own height.

While folded the lane draws no cards at all, which is what makes every
exclusion true by construction rather than by a guard per gesture: no card
face means no marquee target and no navigation frame, and no registered grid
means the masonry's drop zones have nothing to resolve against. What did need
code is the half that names absolute destinations — the option-arrow jumps and
the arrow seed scan past a folded lane, the lane domain's down-arrow is inert
on one, and New Card skips it (a selection inside one falls through to the
last-active lane, the stale selection's rule). A drop on the strip appends at
the lane's end, cards and Finder files alike, with an accent edge standing in
for the shadow the strip has no masonry to open; there is no hover-to-auto-
expand yet. Lane reorder works on the strip, and a dragged folded lane carries
its fold, so its shadow and its replica are the strip rather than its units.

The write is `writeLaneWidths` clause for clause — one `updateIndex` bracket,
the same stamp behaviour, the same three do-nothing paths — with two new
`WriteOperation` cases and two new undo verbs rather than one of each, because
a banner or an Edit-menu row that said "resize" after Collapse Lane would name
a control the user never touched.

Claude-Session: https://claude.ai/code/session_014PtZdPwqZuqEDLc6wZMtEy

KanbanTests/FrontmatterTests.swift

@@ -748,6 +748,52 @@ struct FrontmatterLenientFieldTests {
         #expect(try document("width: banana").width == .malformed(raw: "banana"))
     }
 
+    /// **`collapsed` reads like `width`, one type over** (03-board-ui.md § Lane ▸ Collapsed lanes;
+    /// 01-storage-format.md § Frontmatter's lane table): a boolean scalar reads as itself — including
+    /// YAML 1.1's other spellings, which the parser has already resolved — and a *quoted* one of those
+    /// words coerces, the numeric-string precedent applied to a boolean field.
+    @Test func collapsedReadsBooleansAndTheirQuotedSpellings() throws {
+        #expect(try document("collapsed: true").collapsed == .valid(true))
+        #expect(try document("collapsed: false").collapsed == .valid(false))
+        // YAML 1.1 resolves these to booleans unquoted, so they arrive here already typed.
+        #expect(try document("collapsed: yes").collapsed == .valid(true))
+        #expect(try document("collapsed: off").collapsed == .valid(false))
+        // Quoted, they are strings — and a string that spells a boolean word has a sensible reading.
+        #expect(try document("collapsed: \"true\"").collapsed == .valid(true))
+        #expect(try document("collapsed: \"No\"").collapsed == .valid(false))
+        #expect(try document("collapsed: \"ON\"").collapsed == .valid(true))
+    }
+
+    /// **Everything else has no boolean reading, and therefore renders as expanded** — the default is
+    /// the absent key's, so an unreadable value can never fold a lane by accident.
+    @Test func collapsedIsMalformedForEveryNonBooleanReading() throws {
+        #expect(try document("schema: 1").collapsed == .missing)
+        #expect(try document("collapsed: null").collapsed == .missing)
+        #expect(try document("collapsed: maybe").collapsed == .malformed(raw: "maybe"))
+        #expect(try document("collapsed: 1").collapsed == .malformed(raw: "1"))
+        #expect(try document("collapsed: [true]").collapsed == .malformed(raw: "[true]"))
+        #expect(try document("collapsed: {a: 1}").collapsed == .malformed(raw: "{a: 1}"))
+    }
+
+    /// A lenient field with no reading files a coerce-tier trace and leaves the bytes exactly as
+    /// written — the family's posture, `collapsed` included.
+    @Test func anUnreadableCollapsedFilesATraceAndRoundTrips() throws {
+        let text = "---\nschema: 1\ncollapsed: maybe\nwidth: 2\n---\nbody\n"
+        let parsed = try FrontmatterDocument.parse(text)
+        #expect(parsed.serialized() == text)
+        #expect(parsed.coercedFields == [CoercedField(key: "collapsed", raw: "maybe")])
+        // A readable value is an absence of trace, not a trace of a value.
+        #expect(try document("collapsed: true").coercedFields.isEmpty)
+        #expect(try document("collapsed: false").coercedFields.isEmpty)
+    }
+
+    /// The key is the schema's, so the card window's Details section does not list it beside a user's
+    /// own overlay keys (`FrontmatterKeys.schemaOwned`).
+    @Test func collapsedIsSchemaOwnedRatherThanAnUnknownKey() throws {
+        #expect(FrontmatterKeys.schemaOwned.contains(FrontmatterKeys.collapsed))
+        #expect(try document("collapsed: true").unknownFields.isEmpty)
+    }
+
     @Test func malformedLenientValuesStillRoundTrip() throws {
         let text = "---\nschema: 1\nbackground: [red, blue]\nwidth: 1.5\nicon: {a: 1}\n---\nbody\n"
         let document = try FrontmatterDocument.parse(text)