Captures and the Scratch Pad.

The Scratch Pad is a project-scoped workspace with two tabs: Notes for quick jots and checklists, and Captures for structured items synced from your device. There are three ways into it.

The Notes tab is a persistent, project-scoped pile of quick notes and checklists. Capture them from anywhere in the project, drag them onto card stacks or outlines, or drop them inline into open text, manuscript, or wiki content, and keep them around as long as they're useful.

Two ways to view it

You can open the Scratch Pad as a small popup over your project, or as a full view inside the file container alongside your other open files.

The floating button can be hidden via account preferences (Hide Scratchpad), shows a small badge with the count of unseen notes, and remembers its horizontal position per browser.

Notes and checklists, auto-detected

There are exactly two stored entry types. The Scratch Pad picks which one to render from a single rule: if every non-empty line of the entry starts with -, it's a checklist; otherwise it's a note. Switching between them is just a matter of adding or removing the - prefix.

Remember the inn scene needs
a transition out. Mara
crosses the orchard at dawn.

- Finish chapter 3
- Rewrite the inn scene
- Decide on Mara's last name

The Tasks tab is a project-wide to-do

Both the popup and the full view have three view tabs: All, Tasks, and Notes. The Tasks tab does something useful: it flattens every checklist across all your notes into a single list of items. Toggling a checkbox in the Tasks view updates the original entry. Helpful for "show me everything I have to do across this project, regardless of which entry I jotted it in."

Starting a new entry while the Tasks tab is active auto-prefixes each line with -, so it saves as a checklist.

Drag onto any structured file

Every Scratch Pad entry, and every capture in the Captures tab, shares the same drag type. Drop onto card stack sections or outline nodes to create new structured items. Drop into open text, a manuscript section, or wiki entry body to insert the text inline at the drop point. After a successful drop, the entry is removed from the Scratch Pad automatically.

Composing a new note

1. Click + (or use the toolbar + in the full view). A blank tile appears at the top of the list in edit mode.
2. Type. Enter saves. Shift + Enter adds a newline. Esc discards.
3. Clicking outside the tile saves the entry.

Where notes can come from

Notes don't only come from typing in the popup. Any of these becomes a Scratch Pad note:

• Typed in the Scratch Pad (popup or full view).
• Synced from your device with ::note or ::task.
• Structured device commands (::card, ::wiki, ::outline, ::comment, ::meta) go to the Captures tab or to comments instead, not Notes.

Device-synced notes show a small from FileName link on hover. Click to jump back to the original text file.

Persistence and sync

• Saved per project. One Scratch Pad per project.
• Real-time sync: opening the Scratch Pad in two browser tabs or on two devices keeps them in sync; new notes from a device sync appear immediately.
• Unseen-count badge: the header Inbox button and the floating notepad button both show the number of entries created since you last viewed that tab. The badge clears as soon as the tab is open.

When you type a line like ::card or ::wiki @characters in a text file on your BYOK, Studio recognizes it on sync and turns the lines that follow into a structured item: a draft card, a wiki entry, an outline branch, ready to drop into the right file with one click, or routed there automatically if you set up the rules.

What the inbox looks like

• Inbox / Cards / Wiki / Outlines filter chips at the top. Inbox shows everything that needs action; type chips narrow by capture type.
• Search bar filters visible captures by body text.
• Per-type previews: card-shaped tiles for cards, structured previews for wiki entries, nested-tree previews for outlines.
• Group tiles: consecutive cards from the same device sync collapse into one block with a single Promote all action keeps the inbox tidy after a long sync.
• Promote opens a destination picker: pick a file, pick a section or category, confirm. Auto-routed captures skip this step entirely.
• Drag-and-drop any capture tile onto the same targets as Notes: card sections, outline nodes, or inline into open text, manuscript, or wiki content.
• Source-file link on each tile on hover jumps back to the original text file the capture came from.
• Bulk select with Shift- or Ctrl-click. Bulk promote and bulk delete.

A capture command lives on a line by itself, in the form ::command optionally followed by an @handle. Everything between one command line and the next is the capture's body. Commands are case-insensitive: ::Card, ::card, and ::CARD are all equivalent.

Capture commands are only processed for device text files as they sync into Studio. Typing them in a web-side text file in Studio does nothing. Handles can be any combination of letters, digits, -, and _, and may start with a digit (so @2024 is valid).

::card
A magic forge that only works at dawn.
Bound to the smith's bloodline.

::card @worldbuilding
title: The world-tree
Its roots reach into every dream.

::wiki @characters
title: Mara
A blacksmith's apprentice with a stubborn streak.

::outline @plot
^ Act I
^^ The village burns
--- Mara escapes through the orchard
^^ Mara meets the smith

::meta
folder: drafts
tags: @worldbuilding, @act-one
description: Notes from the train, scene draft for chapter 4.

The forge groaned awake at dawn. [bound to bloodline] ::comment this needs more grounding

This scene needs a sensory detail.
::comment add smoke, sweat, something to ground the reader

::note
Remember the inn scene needs
a transition out.

::task
- Finish chapter 3
- Rewrite the inn scene
- Decide on Mara's last name

Every project has its own routing rules. Open them from Scratch Pad → Captures → Settings (the gear icon). Three layers of routing exist; Studio walks them top to bottom when a capture comes in.

1. Default destinations

For each capture type, you can set a default destination for this project. ::card captures without a matching handle land in the default card stack; ::wiki captures land in the default wiki category; ::outline captures append to the root of the default outline.

• Default card stack: file plus an optional section.
• Default wiki: file plus a category path.
• Default outline: file. Captures append at the root.
• Default folder for new device text files: where device-created text files land if no ::meta folder: is given.

2. Handle mappings

A handle mapping binds a device-side @handle to a specific destination, so ::card @worldbuilding routes to a specific card stack and section, ::wiki @characters routes to a specific wiki category, etc.

Each row is:

@handle  +  capture type  +  destination file  +  section / category

Resolution order at sync time (when auto-route is on):

1. Handle on the command line + matching mapping → route there.
2. No handle, or unmapped handle → project default for that capture type.
3. No project default → the capture waits in the inbox for manual triage.

3. Tag handles

Tag handles are a separate but parallel idea. In Capture Settings → Tag handles, you bind a handle like @t-mara to an existing tag, for example, a tag called "Mara". After that, tags: @t-mara inside a ::meta block applies the right tag instead of creating a fresh one literally named t-mara.

Auto-route toggle

A switch in Capture Settings controls whether captures with a resolvable destination route automatically on sync. With the toggle off (the default), all captures wait in the inbox for manual triage so you can preview and tweak before filing. With it on, captures that resolve to a destination skip the inbox entirely.

A separate Source-file cleanup mode picks what happens to the original device text file: Leave (default: keep the :: lines as written), or Strip (remove processed :: lines after extraction, leaving only the prose).

In Capture Settings → Custom commands, you can map any non-reserved ::token to a built-in capture type, with an optional default handle. Useful for project-specific shorthand.

For example, map ::character → wiki + default handle @characters. Now, on the device, writing:

::character
title: Mara
Stubborn, kind, hates dawn.

…has the same effect as writing ::wiki @characters followed by the same body.

Reserved tokens that can never be overridden: card, wiki, outline, note, task, comment, meta, as.

Sometimes a whole text file is the structured item. You sat down on your device and beat-sheeted Act I in a single go. File Mode handles that case. If the first non-blank line of a device text file is ::as outline, the entire file is treated as a single outline rather than parsed for capture blocks.

::as outline
title: Act I beat sheet

^ Opening
^^ The village burns
--- Mara escapes
^ Rising action
^^ Meeting the smith

What happens on sync:

• A new Outline file is created in your project, named from the title: line, or the source file name if no title is given.
• The original text file is consumed, hidden from the drawer so you don't see two copies of the same content. It still exists in the database; the outline keeps a reference to it.
• Re-syncing the same source updates the outline in place.
• If you've edited the outline in Studio and then re-sync the source, the next sync creates a sibling outline rather than overwriting your Studio edits. Your work is never silently replaced.

Only outline is supported as a File Mode type today.

Comments are a sibling to captures, not a sub-feature. Both can come from a device sync, but they live in different places and serve different purposes. Captures populate the inbox. Comments anchor to text file content and live in a column beside the text (Google Docs style).

What it looks like in Studio

• Open a text file that had ::comment lines on its last device sync. Bracketed sections are highlighted in the body.
• A column on the right shows comment cards aligned to their highlights.
• Click a highlight → the matching card scrolls into view. Resolve, edit, or delete from the card.
• Web users can add comments directly in Studio (select text → comment). No device required.

How comments survive edits

• Anchored highlights (bracketed […] ::comment) re-anchor by snippet match on every re-sync, so editing surrounding prose on the device doesn't break the link.
• Positional comments (::comment on its own line) re-attach to the preceding paragraph by snippet match.
• Orphaned comments (anchors lost after a big rewrite) pile in their own section at the bottom of the column so they're not lost. You can re-anchor them by hand.

Everything in Scratch Pad → Captures → Settings (the gear), in one list.