Paper trail for the third wave — interchange, labels, the reshaped menus, and the day's chrome fixes

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

CHANGELOG.md

@@ -1,5 +1,49 @@
 **August 2026**
 
+A board now exports as a single file — Obsidian Kanban Markdown, a plain Markdown outline, or CSV — from File ▸ Export.
+
+File ▸ Import Board… turns an Obsidian Kanban file, a Markdown outline, or a CSV into a fresh board, detecting the format for you.
+
+Cards can now carry labels, managed from the card window's new Labels section or the context menu's labels submenu.
+
+The card and lane context menus are reorganized into tidy groups — open, style, clipboard, navigation, width, and trash where each belongs.
+
+Move Left and Move Right on a card's context menu now really move it into the neighboring lane, keeping its position.
+
+The Paste row now says what it is about to paste — Paste Card, Paste Lane, or a count of either.
+
+A card's title can now be edited directly in the card window's Edit mode.
+
+The card window's sidebar hides and shows with a new trailing toolbar toggle or View ▸ Show Sidebar.
+
+Delete and Reveal in Finder moved from the card window's sidebar into its toolbar.
+
+The attachments section now sits at the bottom of the card window's sidebar.
+
+The color and symbol pickers now match — compact square combos, four new palette colors, and the system color panel behind Other….
+
+A new symbol browser offers every symbol the system knows, searchable and grouped by category.
+
+Choose Image… in the style editor sets any picture as a board's background.
+
+Generated and pasted board backgrounds now keep to a tidy folder of their own, and replaced ones are cleaned up automatically.
+
+A file copied in Finder now pastes onto a card as an attachment with ⌘V.
+
+The card window now offers a visible paste button in its attachments header whenever the clipboard holds an image.
+
+A card's comments column can now be resized by dragging its divider, and the width sticks.
+
+A board's background image now stays behind the title bar instead of vanishing there after a trip away from the window.
+
+The board window no longer shows its name twice in the title bar.
+
+The card window's title bar no longer collapses into a single line after switching between edit and source modes.
+
+The lane collapse chevron now shows the standard cursor instead of a resize arrow.
+
+Every board's agent guide now teaches the comment-thread etiquette and arrives with a vendor-neutral AGENTS.md twin.
+
 An image on the clipboard now pastes straight onto the selected card as an attachment — with Set as Hero and Paste as Board Background alongside.
 
 Press Space on a .kanban board in Finder for a Quick Look preview outlining its lanes and cards.

README.md

@@ -23,7 +23,7 @@ Lanework is in early development. This list tracks what has actually shipped and
 
 - **The clipboard** — ⌘X/⌘C/⌘V move cards *and* lanes, within a board and across boards, so structure transfers without a mouse. It's a hybrid: the pasteboard carries a small manifest plus the titles as plain text, while the real content — whole folders, attachments and strays and all — is snapshotted into Application Support the instant you press ⌘C, so a copy captures the item as it was at that moment and survives the original being deleted, its volume unmounting, or the app quitting and relaunching. The store keeps exactly one snapshot: every copy and every launch sweeps whatever the pasteboard no longer points at. If a snapshot has gone missing by the time you paste, the manifest still carries each item's full `index.md`, so the paste lands with its content intact — and says so out loud, naming exactly what was left behind ("Pasted 'Fix login' without its 2 attachments") rather than leaving you to find an empty `attachments/` later. Cut is Finder-style deferred: the items dim in place and stay put until a paste moves them, voiding if another app takes the pasteboard or the source board closes (the paste then quietly becomes a copy), and voiding *per item* if one is deleted in the meantime — so a paste moves whatever survived, and a cut emptied down to nothing simply does nothing. Paste lands after the anchor card, at a selected lane's bottom, or at the last member of a multi-selection in flatten order — the same anchor ⌘N uses — and a lane payload lands after the anchor lane or at the board's right end, which is one of the two ways out of a board with no lanes at all. Copies keep `created` and take fresh identities throughout; a lane carries exactly its cards, copied or moved, because the trash is board-level and there is nothing lane-nested to strip; pasting a lane back into its own board is the within-board duplicate the drag deliberately doesn't offer. The clipboard works on trash cards like on any card — ⌘C yields a live copy wherever you paste it, and ⌘X in the trash followed by ⌘V is the keyboard-native restore, a card into a lane and a trashed lane row after the anchor lane — while paste never targets the trash itself, and the read-only lock blocks cut without ever blocking copy, because copying out is a read. Copy Link on a card's context menu writes the card folder's file URL and plain path in one pasteboard write — a link to the files themselves, ready for notes, scripts, or Terminal. An image on the pasteboard pastes too: ⌘V lands it as a named attachment on the selected card through the ordinary import path, the attachment row's Set as Hero / Remove Hero (with File-menu twins) crowns one as the face's banner, and the board popover's Paste as Board Background gives the same bytes their third home — file-shaped flavors travel byte-for-byte, TIFF re-encodes to PNG, and PNG wins among several.
 
-- **Styling** — one style editor serves every anchor: a background grid of the twelve palette wells behind a leading None well that *removes* the key, and a curated symbol grid — boards, lanes, and cards each drawing from their own kanban-relevant shelf — behind a leading level-default well that does the same. It is selection-aware (the selected cards or lanes; the board with nothing selected) and states the current value per dimension across the whole target set — agreement selects a well, disagreement reads "—", and a hand-written hex or uncurated symbol states itself verbatim outside the grids, replaced by any well you choose. A batch applies as one bracketed commit that skips every target already carrying the value, and the open editor tracks its targets live: one deleted out from under it leaves the set, and the last one closes the editor rather than quietly retargeting the board. Reached from Board ▸ Style… (⌥⌘S) or a card's or lane's context menu, where a compact row of app-wide recent colours recolours in one click and a lane's menu also carries its width stepper. Colour renders at all three levels — a card's `background` as a left-edge stripe, a lane's as a full-width band along its top edge, the board's as the window's content background — each painting nothing at all when the value doesn't resolve, bytes on disk untouched. **A board can also wear a picture.** `background` is a mapping at every level — `{color: fern}` on a card or a lane — and a board's may name an image beside its colour: `background: {color: "#112233", image: art/sunset.jpg}` paints that image over that colour, scaled to fill, across the **whole window**: the content runs under a transparent title bar with a frosted strip keeping the toolbar and the board-name widget legible on top of it. The path is relative to the board folder, so the picture travels with the document when it is copied, zipped or synced (an absolute path, or one climbing out of the folder, simply paints nothing). Either half may stand alone, the colour shows through while a large photograph decodes off the main thread, and replacing the file in Finder swaps the backdrop live. The board popover's Theme tab dresses the board from presets: a Solid color / Pattern choice over one eight-hue carousel with chevron paging. Solid color filters by tone (defaulting to the current appearance) and saturation, and clicking a flat swatch writes that color and clears the image; Pattern adds color-count (mono, complementary duo, contrasting trio) and mesh-density filters over live previews of a faceted triangle-mesh recipe, with a Reroll button re-minting the geometry — clicking a swatch renders it at full resolution into the board folder as `facets.png` and points `background` at it, with the recipe's primary color written beside it as the fallback underlay. Preset or dragged in, a background is always static pixels — the raw file stays the escape hatch — and a board with no background of its own keeps the standard window chrome exactly as before.
+- **Styling** — one style editor serves every anchor: a background grid of the sixteen palette wells behind a leading None well that *removes* the key (an Other… affordance opens the system Colors panel — a palette-exact pick stores the name, anything else the hex), and a curated symbol grid — boards, lanes, and cards each drawing from their own kanban-relevant shelf — behind a leading level-default well that does the same, with a matching pair of compact color/symbol combo fields and a standalone searchable, categorized symbol browser derived from the OS's own catalog one click deeper. A board can also take any picture as its background via Choose Image… (copied into the app-claimed `.backgrounds/` folder, where replaced images tidy themselves). It is selection-aware (the selected cards or lanes; the board with nothing selected) and states the current value per dimension across the whole target set — agreement selects a well, disagreement reads "—", and a hand-written hex or uncurated symbol states itself verbatim outside the grids, replaced by any well you choose. A batch applies as one bracketed commit that skips every target already carrying the value, and the open editor tracks its targets live: one deleted out from under it leaves the set, and the last one closes the editor rather than quietly retargeting the board. Reached from Board ▸ Style… (⌥⌘S) or a card's or lane's context menu, where a compact row of app-wide recent colours recolours in one click and a lane's menu also carries its width stepper. Colour renders at all three levels — a card's `background` as a left-edge stripe, a lane's as a full-width band along its top edge, the board's as the window's content background — each painting nothing at all when the value doesn't resolve, bytes on disk untouched. **A board can also wear a picture.** `background` is a mapping at every level — `{color: fern}` on a card or a lane — and a board's may name an image beside its colour: `background: {color: "#112233", image: art/sunset.jpg}` paints that image over that colour, scaled to fill, across the **whole window**: the content runs under a transparent title bar with a frosted strip keeping the toolbar and the board-name widget legible on top of it. The path is relative to the board folder, so the picture travels with the document when it is copied, zipped or synced (an absolute path, or one climbing out of the folder, simply paints nothing). Either half may stand alone, the colour shows through while a large photograph decodes off the main thread, and replacing the file in Finder swaps the backdrop live. The board popover's Theme tab dresses the board from presets: a Solid color / Pattern choice over one eight-hue carousel with chevron paging. Solid color filters by tone (defaulting to the current appearance) and saturation, and clicking a flat swatch writes that color and clears the image; Pattern adds color-count (mono, complementary duo, contrasting trio) and mesh-density filters over live previews of a faceted triangle-mesh recipe, with a Reroll button re-minting the geometry — clicking a swatch renders it at full resolution into the board folder as `facets.png` and points `background` at it, with the recipe's primary color written beside it as the fallback underlay. Preset or dragged in, a background is always static pixels — the raw file stays the escape hatch — and a board with no background of its own keeps the standard window chrome exactly as before.
 
 - **The trash** — deleting a card **moves** it: its folder travels into the board's reserved `.trash/`, always landing at the top, and View ▸ Show Trash reveals a trailing column where those cards live. A trashed card is an ordinary card in a special place — the same card face, the same colour stripe, the same attachments chip, the same search, the same selection, the same clipboard — so `.trash/` is self-describing in Finder and to agents, and there is no tombstone flag anywhere. **Lanes delete into the trash too**: the folder travels subtree-intact and shows as one distinct dimmed row carrying its title and held-card count — an opaque unit that never expands, whose cards aren't individually addressable, and which restores whole or purges whole (its confirmation counting the cards it would take with it). The column takes exactly one width unit while shown, so showing it re-divides the window rather than resizing it, and its newest-first order falls out of ordinary ranks with no timestamp sort. There is no Put Back: restore by dragging a card out into any lane at any position, or ⌘X in the trash and ⌘V into a lane — both are ordinary moves, so a restored card lands where you put it. Drop a live card on the column to delete it — the pointer's twin of ⌫, writing the identical move, and its shadow always takes the top row because that is genuinely where the card lands. Delete is one vocabulary staged by place: ⌫/⌘⌫ moves a board card to the trash and deletes a trash card permanently, and ⇧⌘⌫ Empty Trash… purges the whole container — each confirmed where the loss is real, named by count, and Empty Trash always covers the whole trash, never just what a filter is showing. Nothing edit-shaped — Open, Rename, Style…, Finder file drops — applies to a trash selection, and a selection never mixes trashed with live.
 
@@ -51,11 +51,13 @@ Lanework is in early development. This list tracks what has actually shipped and
 
 - **Customizable toolbars** — both windows carry a real macOS toolbar: right-click ▸ Customize Toolbar…, drag to rearrange, the system overflow, and the Icon and Text / Icon Only / Text Only display options, with your arrangement remembered across launches. They are pure enhancement — every item is a menu command with a shortcut, so removing all of them costs you nothing but a click. The board ships with the search field alone, trailing, and offers New Card, New Lane, Zoom In, Zoom Out, Undo, Redo and Show Trash in the palette (Undo and Redo validate exactly as the Edit menu's rows do, and keep static labels because the menu's titles rewrite themselves); the board popover deliberately has no item, since the window-title chevron is its home. Take the search field out and ⌘F still summons search — the field appears in a strip just under the title bar and stays until the search clears, keeping the keyboard while you type. The card window ships Edit Body · Raw Source · Add Attachment, the first two as toggles showing their on-state, with Edit Body disabling while raw source is up and Add Attachment live in every mode.
 
+- **Import and export** — a board leaves as one file and comes back as one: File ▸ Export writes the frontmost board as Obsidian-Kanban-plugin Markdown, a plain Markdown outline, or CSV (lossy exports post a quiet notice naming what was omitted), and File ▸ Import Board… turns any of those into a fresh board with the format auto-detected, never user-picked — headings become lanes, rows become cards, document position becomes the order. Convert-once by design, no live sync; and because a board folder is already nearly a valid Obsidian vault, plain interop needs no converter at all.
+- **Labels** — the `labels` card key is first-party now: a YAML list of strings managed from the card window's Labels sidebar section (removable rows, autocomplete over the board's used-label universe, free-text creation) and the context menu's labels submenu — twelve frequency-then-recency ranked checkmark toggles plus a More… dialog over every used label. Read leniently, written canonically, case-insensitively unique per card, the key removed with its last label; face rendering and search integration deliberately await their own passes.
 - **Sharing and Quick Look** — File ▸ Share… stages the board in front as a zip — `.git` excluded, the staging cancellable and cleaned up either way — and hands it to the system share sheet, so a board travels by Mail, Messages, or AirDrop as one file. A Quick Look extension answers Space in Finder with a lane-by-lane outline of any `.kanban` package, rendered for light and dark, built on a capped never-throwing outline walk rather than the full loader — a preview never fails on a board the app could open.
 - **Printing** — File ▸ Print (⌘P) prints the board in front as a flowing linear document — lanes left to right, each lane's cards top to bottom, never a screenshot of the strip — or, from a card window, that one card. A print-panel accessory with the system's live preview picks the components (title, icon and labels, rendered body, comments in either reading order), the page breaks (continuous, per lane, per card — real sheet boundaries), one base face and size every other size derives from, and a toggleable header and footer; option sets persist as named profiles, with Last Used auto-captured from the panel. Scope resolves at invocation — the board in front, the card window's card, or a polite refusal where neither exists — Finder-initiated prints of a board work too, and the trash is unreachable by construction.
 - **Undo** — ⌘Z and ⇧⌘Z are native macOS undo, per board: one stack owned by the board's session and shared by every window over it, so a card window's ⌘Z crosses the same step the board window's does, and another board's never does. Every app-mediated mutation registers an inverse at the write boundary — create, move, reorder, rename, restyle, resize, delete, and an Edit session's whole run of saves — with a restore registering as the ordinary move it is — one gesture to one step, named in the app's own vocabulary so the Edit menu reads "Undo Move 3 Cards" and the toolbar's twins light up and dim with it. Undoing is a real write, never an in-memory revert: it goes through the same atomic writer, echoes back through the watcher, and refreshes every window. Because the app is not the only writer, each step re-checks its target the moment you press ⌘Z — field by field, against what its own write left — and a step the disk has moved past is **skipped rather than applied**, with a quiet row saying which item changed outside Lanework, while ⌘Z falls through to the next step; a step that merely failed to write (a full disk, an unplugged volume) stays put to be retried. Permanent deletion and the duplicate-id repair are deliberately outside it — the confirmation is the safety — attachment add and remove register nothing in v1, and foreign edits never join the stack. The read-only lock disables Undo and Redo with every other mutating command and gives them back, stack intact, when it clears. The stack lives with the session and dies at close, standard macOS behaviour. This stack is the app's only history substrate, and the provider seam it binds through is kept deliberately open — a future provider (the deferred foreign-change journal) re-binds without re-plumbing.
 
-- **The agent guide** — every board root carries a `CLAUDE.md` the app writes and keeps current: a condensed, agent-facing rendition of the schema — the folder layout, ordering arithmetic, creating and moving cards, the `.trash/` convention, `attachments/`, `modified-by` self-stamping, the colour and icon palettes, and the git etiquette — so any file-capable agent dropped into the folder already knows how to work the board. It is app-owned and version-gated by a marker in its first line: rewritten when missing or older, left byte-for-byte alone when current or newer, and re-checked on every reload, so a guide deleted or rolled back from outside heals by itself. A `CLAUDE.md` that isn't the app's is never clobbered — it moves to `CLAUDE.user.md` (the user's own extension point, which the app otherwise never touches), and if that name is taken the app simply doesn't write a guide. A symlink or folder wearing the name is moved aside — Finder-style, never destroyed, with a quiet row naming where it went — because the app owns that name; and a board on a read-only volume is skipped in silence: the guide is a courtesy and never an interruption.
+- **The agent guide** — every board root carries a `CLAUDE.md` — and a byte-identical, vendor-neutral `AGENTS.md` twin — the app writes and keeps current: a condensed, agent-facing rendition of the schema — the folder layout, ordering arithmetic, creating and moving cards, the `.trash/` convention, `attachments/`, `modified-by` self-stamping, the colour and icon palettes, and the git etiquette — so any file-capable agent dropped into the folder already knows how to work the board. It is app-owned and version-gated by a marker in its first line: rewritten when missing or older, left byte-for-byte alone when current or newer, and re-checked on every reload, so a guide deleted or rolled back from outside heals by itself. A `CLAUDE.md` that isn't the app's is never clobbered — it moves to `CLAUDE.user.md` (the user's own extension point, which the app otherwise never touches), and if that name is taken the app simply doesn't write a guide. A symlink or folder wearing the name is moved aside — Finder-style, never destroyed, with a quiet row naming where it went — because the app owns that name; and a board on a read-only volume is skipped in silence: the guide is a courtesy and never an interruption.
 
 - **Accessibility** — the board is a real VoiceOver surface, not a grid of unlabelled rectangles: lanes are containers read as "⟨title⟩, lane, N cards" (the count is the filter's, like the visible badge), each card is one flattened element carrying its title, its attachment count and its cut-pending state, and traversal follows card `order` rather than masonry column position. VO-Space toggles selection through the same funnel a ⌘-click uses, context-menu rows double as custom actions, lane titles are headings for the rotor, and the trash column pins last. A **live board announces itself**: a foreign edit lands as one polite, non-interrupting digest per reload — "Board changed: 2 cards edited, 1 card added" — while the app's own writes stay silent. Which is which is decided **per file by the write-provenance ledger**, never by which kind of reload delivered it: a reconciling sweep on wake or reactivation announces whatever changed in the blind window (the app never vouches for changes it didn't witness), and a foreign edit that lands on a file the app had just written is still announced. A card that disappears under the cursor is named rather than merely lost ("Card 'Fix login' was deleted externally"), with focus recovering to its lane; when the lane went too, the announcement names the *lane* and its count and focus walks up then sideways to whatever now holds its position. Bracketed operations say one thing at completion and never their internal churn, and the banner strip is an announced element in its own right — the read-only lock and reload breakage speak when they appear and when they clear. **Every size in the app is relative**: there is not one hard-coded point size left — the card face, the lane header, the masonry, the style editor's wells and every window's floor derive from the system body font, so the whole board grows with the system text size while the no-horizontal-scroll rule holds (the lanes compress, the strip never scrolls) and titles keep truncating gracefully. **View ▸ Zoom In / Zoom Out / Actual Size (⌘+ / ⌘− / ⌘0) is that scaling's control**, since macOS ships no text-size setting of its own: eight rungs from 75% to 200%, moving the type, the card chrome and the lane chrome together off one ruler, remembered across launches and shared by every open board window. It is a zoom, not a magnification — the lanes still divide the window's width, because every lane being on screen is the rule the board is built around; what changes is how large the cards are and how many of them fit. Actual Size draws exactly what the board drew before zoom existed, down to the pixel, and each rung announces itself to VoiceOver. The system's visual accommodations are wired throughout: **Increase Contrast** thickens every border and selection ring and gives card and lane plates an outline they don't otherwise have, **Reduce Transparency** turns the transient search bar's glass and the trash column's washes solid, and **Reduce Motion** has a variant for every animated surface in the app — movement goes instant, appear/disappear goes crossfade, uniformly, the live-reload seam included. **A coloured board computes its own text colour.** The board background is the one surface the app lets a colour sit behind text, so the ink is chosen rather than assumed: WCAG relative luminance against the ≥ 4.5:1 threshold, with an `#RRGGBBAA` value composited over the window background of the appearance you are actually in — so lane and trash headers take light or dark glyphs on their own and re-decide the moment you switch to Dark Mode. One path serves both halves of the styling vocabulary: the twelve palette wells are pinned by a test that checks the ink the app *picks* for each of them in both appearances (a dark palette board is now readable in Light Mode, which it was not), and a hand-written hex — which stays fully honoured from disk — gets the identical computation as it renders. Nothing is ever said by colour alone (selection is a ring plus a trait, a cut card is dimmed plus "cut, pending paste", the trash header is hatched plus labelled, a mixed batch reads "mixed"), and under **Full Keyboard Access** the board is a single visible tab stop with the arrow grammar inside it while every control around it — lane buttons, popovers, the style grids, welcome rows, template tiles — is Tab-reachable, arrow-navigable and labelled.