Types and fields

A type says what a kind of thing in your notes is, such as a person, a team, or an incident, and which fields it has: a team’s lead, the areas it owns, who is on call. The fields are front matter you write, or already wrote, in plain Markdown. Deckard reads them as a table you can search, sort, and group, works out the other side of each relation, and answers questions such as who leads the team that owns checkout? from Find, a hover, a page, or an assistant.

A workspace with no types works as it always has. The work sample ships five types to try: Person, Team, Area, Decision, and Term.

Two kinds of type

• Things you mention. Teams, people, areas, systems: you already write them as tags, #team/payments or @noor-haddad. A type over a tag namespace makes every tag in it a row, whether or not a note describes it. A row’s fields live in the front matter of its hub note, the note whose describes: names the tag.
• Notes you write. Incidents, decisions, meetings: each is a note of its own. A type of notes makes each note whose front matter says type: incident a row, and its fields are that note’s front matter.

A type note

Each type is one note in the Types folder of your notes folder (deckard.notesFolder). The folder’s name is fixed. Deckard reads its notes as types and leaves them out of searches, counts, Find, Related notes, and the overviews, as it does the templates folder, so their tags and tasks never count as your notes’.

---
deckard-type: team
rows: "#team/*"
notes: teams/
---
# Team

| Field   | Kind       | Reverse     | Also called     | Words                           |
| ------- | ---------- | ----------- | --------------- | ------------------------------- |
| lead    | Person     | lead of     | head            | leads, led by, now leads, heads |
| owns    | Area, many | owned by    | responsible for | owns, took over                 |
| on-call | Person     | on call for | oncall, pager   | is on call for, covers          |
| channel | Text       |             | slack, support  |                                 |

Every #team/ tag is a team. Text below the table describes the type.

The first table whose header has Field and Kind lists the fields, one to a row, in any case:

• Field is the front-matter key, such as lead, on-call, or Distribution List. A name in words is written in front matter as it is, Distribution List: ["@dana"], and reads the same with hyphens, distribution-list:, which is how a search names it.
• Kind says what its values are; see below. Add , many for a field that holds several, Area, many.
• Reverse names the field the other side of a relation gets: a team’s owns makes each area owned by that team. Left empty, it is the field’s name and of, owns of. In a search, its spaces are hyphens: owned-by.
• Also called lists other words for the field, separated by commas, which Find reads in a question.
• Words, which you may leave out, lists the phrases a line uses to say the field, separated by commas: leads, led by, now leads. On a line such as @priya-natarajan now leads #team/fx, the lightbulb then offers to set the field; see File this.

Other columns are yours, and kept when Deckard rewrites the table. What Deckard cannot read in a type note, such as a kind it does not know or a field listed twice, is marked in the editor.

Kinds

Field names a search already uses

A search already reads some words as its own fields: status, owner, start, note, type, title, and the others in the query language. A field named one of them is still read and shown, is marked in its type note, and is reached in a search as field.status. Name such a field something else, such as state, to search it by name.

Rows

Rows of a namespace. Every tag under the namespace is a row, with a hub note or without one. A nested tag, #team/payments/fraud, is a row too, with a parent, #team/payments, which lists it among its children; a level no note writes is filled in. @noor-haddad and #person/noor-haddad are one row, as they are one person everywhere in Deckard.

Rows of notes. Every note whose front matter says type: incident is a row of the type keyed incident, titled by the note. A type: that names no type is an ordinary field.

A note can be both, the hub note of #team/payments and a type: decision; both types read the same front matter. A heading in a daily note is never a row: it has no front matter.

Writing values

---
describes: "#team/payments"
lead: "@alex-rivera"
owns: ["#area/checkout", "#area/card-payments"]
on-call: "@sam-okafor"
channel: payments-eng
---
# Payments

Deckard writes each value one way, and reads what you write by hand as well:

• Quote a tag: YAML reads an unquoted # as a comment.
• A value that names nothing is kept as text, and marked in the editor: No person is named “Omar H” yet.
• A value written as a tag still tags every entry in its note, as front matter always has: the Payments note is listed on @alex-rivera’s page. A value written loosely, lead: Alex Rivera, finds the row without tagging anything.
• When both sides of a relation are written, Noor’s team: and the team’s own members:, they are read together; a field that holds one value and is given two is marked.

Computed fields

Every row also has fields no note writes, worked out from the notes each time they are read:

Building a type

You never need to write the table by hand. Deckard: New Type… asks the type’s name (Org), then what its rows are: the namespaces in use, the closest to the name first (Each #org/… tag · 14 tags, 9 with a hub note), Another namespace…, Each person, or Each note that says type: org. Deckard writes Types/Org.md, opens it beside, and opens the type form on it.

Deckard: Edit Type… opens the same form on the type note in front, the type of the row note in front, or a type you choose. It is also on a type note’s title bar, on the Edit Type… lens over its table, in ⋯ on a type’s page (Edit type…), and on a column’s menu there (Change field…). The form lists:

• The fields, in the table’s order, each with its kind and, below it, what else is set (Reverse: lead of · Also called: owner) or what is wrong with it.
• Add field…: the field’s name (the box says how it is written and searched: Written in front matter as Distribution List:, searched as distribution-list.), its kind, whether it holds one value or several (each shown as a row’s front matter writes it), and, for a field that names people or rows, what the other side calls it. Each step has a Back button.
• Rows, New notes go in (a type of tags), and Open Types/Org.md; the button in the form’s title opens the note beside.

The kinds are listed with an example of each: Person, each of your types, More than one type… (Team or Area), and Note, then Text, Number, Date, Select… (which asks its options), Checkbox, Link, Email, and Phone.

Choosing a field opens its menu, each row with what it is now: Rename… (Rename field everywhere), Kind, Holds one or several, Reverse, Also called, Words, Move up, Move down, and Remove from Org. Removing takes the row out of the table and nothing else: notes that write the field keep it, shown as one of their other keys.

Each change is written when you make it, as its own write that Deckard: Undo Last Change takes back, and the form is drawn again from the note, so an edit you make by hand meanwhile is kept. The table is written aligned, with your own columns, a separator’s alignment, and a Field cell in backticks kept.

Writing the table by hand still works. In a type note, the lens over the table offers Edit Type…, Add field…, and the type’s count of fields and rows, which opens its rows; a hover on each header cell says what the column holds, the Kind header listing every kind; and Format Document realigns the table.

Create Type from Tags

Deckard: Create Type from Tags…, also Create type from #team… in ⋯ on the page of a tag whose namespace has no type, makes a type from what your notes already write:

1. Choose the rows: a namespace with its counts (#team · 6 tags · 5 hub notes), @ people, a type: value in use (type: incident · 7 notes), or New note type….
2. Choose the fields: each key the rows’ notes write, all chosen, with a guessed kind, how many notes write it, and its reverse (Person · 5 of 5 · reverse: lead of). Values that are tags of one namespace guess a relation to that namespace’s type, or Person; dates guess Date, numbers Number, addresses Link or Email, and a few short values used again and again Select. A field whose name a search already uses is written as team-status, and the list says so.
3. Deckard writes Types/Team.md, opens it beside, and marks any value that does not fit, with quick fixes such as Allow Area or System and Create a System type.

It is one write, which Deckard: Undo Last Change takes back. New note type… asks a name and writes a type of notes with an empty table to fill in.

A Term type

A term note says what a short term in your notes means, such as NDF or 3DS, and Deckard reads it wherever the term is written (see Terms). The work sample’s Types/Term.md is a type of notes with one field, term:

---
deckard-type: term
rows: notes
notes: terms/
---
# Term

| Field | Kind | Reverse | Also called           |
| ----- | ---- | ------- | --------------------- |
| term  | Text |         | acronym, abbreviation |

Its rows are the notes whose front matter says type: term, such as terms/3DS.md, whose first paragraph is the definition. Deckard reads a term note with or without the type, and Make a term note on a term’s hover, or Define… on Stats, opens the form for one either way.

Adding a note of a type

Deckard: New Note from Type… lists your types, each with where its notes go and how many it has (Teams/ · 5 rows, type: incident · 7 notes), then opens a form for a new one. Add team… in ⋯ on a type’s rows opens the same form, and so do the quick fix Create person “Omar H”…, with the title filled in, and Create hub note on a tag a type has rows of, from its page, its row, or Deckard: Create Hub Note for Tag…, with the tag kept.

The form is one list that stays open, as Add Task’s is. Its title says where the note goes, Add a team to Teams/, and the line under it what will be written, Teams/Risk Tech.md · #team/risk-tech.

• Folder is the type’s notes: folder, or its plural name. Choose it for another folder with notes in it, or write a new one.
• Title names the note, and, for a type of tags, the tag. Enter opens it first.
• Tag, for a type of tags, follows the title until you write one: risk is #team/risk, and a nested rates/emea is #team/rates/emea.
• Fields lists each field of the type in its table’s order, with its value or Not set. Choosing one opens its input by kind: the rows it can name, each with its first relation, several for a , many field, and a name that is no row yet is kept as written; a select’s options; a date in plain words, as the task editor reads one; a box for a number, an email, a link, a phone number, or text, which says as you type when the value does not fit. A checkbox turns Yes, No, and Not set in place. Each input offers Clear once the field has a value.
• Create the note writes it. A note with no title, a title that cannot name a file or a tag, a tag that already has a hub note, or a note already at that path keeps the form open on the row to change, saying why. Nothing is written over.

The note is the type’s template (team.md in your templates folder), its questions asked once you create it, or else each field’s key; each field you set is written in, in place of the template’s value, as Deckard writes values: lead: "@dana", owns: ["#area/fx"], start: 2026-03-01. It is one write, which Deckard: Undo Last Change takes back, and it opens in the editor.

Editing fields

The same form edits a note that exists. Edit fields… opens it: on the Note page, at the end of the fields and in ⋯; on a tag’s page, beside Open in the hub note’s card; in ⋯ on a row of a type’s rows; and in the editor, as Deckard: Edit Fields…, on the note in front. A field’s name on either page opens it at that field’s input.

Its title names the note, Edit fields: Noor Haddad, and the line under it the type and where the note is, Person · People/Noor Haddad.md. Editing never moves or renames the note, so there is no Folder, Title, or Tag.

• Fields lists each field with the value the note holds, read as Deckard writes it, @dana by its title, or as written when it names nothing yet. Each opens the same input as in a new note, with Clear. A field written in a way Deckard cannot rewrite safely, such as a block of lines, says Edit in the note, and choosing it opens the note at that line.
• From other notes lists what other notes set on this one, each with its values and where it is set: Set in Payments’ lead, Set in each person’s manager. Choosing one opens the note that sets it at that line, or, when several do, the search for them.
• Save changes writes the fields you changed, and nothing else: every other key, its order, and its comments stay as written. It is one write, which Deckard: Undo Last Change takes back whole; the message offers Undo too. Until a field changes it says No changes, and Enter closes the form. If the note’s front matter changed since the form opened, nothing is written and Save changes says so; close the form and open it again.

Leaving the form for another note with changes not saved asks first. Escape closes it without saving.

A type’s rows

Search type = team, or select a namespace heading a type has in the Hubs view, and the search page is titled with the type’s plural name, Teams, and under it what its rows are, #team/*, or type: incident · Incidents/. A new first tab, Teams (4), beside Notes and Tasks, is a table of the rows the search finds; side by side, the table is above both.

• Columns. The title, then each field, headed by its key in monospace, then Open tasks and Last mentioned, headed in muted sentence case: Computed: not written in the note. Team columns, in ⋯, adds or removes any of them: the reverses, such as Members, Mentions, a nested row’s Parent and Children, and a note row’s Linked from.
• Cells. A person or a related row is a link by its title. A reverse of people lists three by first name and how many more, Dana, Sam, Lena +2. A date reads today · 2026-10-08, and open tasks 4 · 1 overdue.
• A row with no note says so, No hub note · 6 entries, with Create hub note on its row, which opens the form with the row’s tag.
• ⋯ on a row opens it or its hub note, offers Create hub note, Edit fields… for a row with a note, and copies its email.
• Sorting. Select a heading to sort by it, and again for the other way. While it is sorted, Sorted by lead and Sort A-Z sit beside the tab; Sort A-Z goes back to by title.
• A heading’s menu, by right-click or Shift+F10: Sort A-Z, Sort Z-A, Hide column, then Change field…, which opens the field’s menu in the type form, Rename field everywhere…, and Edit in Types/Team.md. Right-click a select’s value for Rename option everywhere…. A rename asks the new name, then shows every note it changes, the type’s table among them, in the refactor preview, as one write.
• Group by, in ⋯, adds each select, person, and relation field, then each reverse, such as members. A row with two values is listed under both, and the rows with none come last, No team.
• Refine offers each select field’s options, counted over the rows.
• ⋯ adds Add team…, which opens the form for a new note on the type, and Open Types/Team.md.

• **Table

  Board**, beside the sort note, shows the rows as the table or as a board.

• The columns, sort, group, and board are kept for each type in this workspace. Save search… puts the table’s search on Home, as any search.
• The Notes and Tasks tabs list what the search finds, as on any page: the notes and tasks in the rows’ notes, and, for rows of a namespace, everything their tags are on.

A board of rows

Board shows a type’s rows as cards in columns, one column per value of a field, as the Task board shows tasks: initiatives by state, incidents by severity, teams by tier. Nothing is special about any type; any type with a select, person, or relation field has a board.

• Group chooses the field the columns are by, and Lanes a second field, or None: each lane is a row of cells across the columns, one per value, so a board of initiatives can be by state and, down the page, by team. Both offer what Group by offers. Group starts as the table’s Group by, or else the type’s first select field, or else its first person or relation field; Lanes starts as None. Both are kept for each type.
• Columns and lanes. A select’s options, in the order the type lists them, empty ones too, so a card can be moved into an option no row has yet. A relation’s rows, every row of the types it takes, by title. A person field’s people, those some row names. A reverse’s values, those some row has. Then No state, last, when a row has none or the field can be written. A row with two values of a field is a card in both.
• Heads. The column heads are drawn once, at the top, each with its count over every lane and its +. A lane’s head is its name, which folds and unfolds it while the page is open, its count, and its +.
• Cards. A card is the row’s title, which opens the row as the table’s title does, then up to three of the table’s columns, in its order, as label value, leaving out the two fields the board is by. Within a cell, cards follow the table’s sort, by title when it has none. A row with no hub note says No hub note · 2 entries, with Create hub note.
• Moving a card. Drag a card to another cell, or choose Move to a column or Move to lane in its ⋯, and Deckard writes the fields the cell stands for in the row’s note, as the form writes them, as one write that Deckard: Undo Last Change takes back; the message offers Undo too. A field that holds one value takes the new one; one that holds several swaps the value the card left for the one it entered; No state takes the value out. A row with no hub note gets one, written at once with the field set. A reverse is set by other notes, so while a card is held its other cells fade and say Set by other notes. Escape lets go of a card.
• + on a column or a lane opens the form for a new note with the column’s and the lane’s values filled in.
• A type with no field to group by says so, with Add a field…, which opens its type note at its table.

Fields on the Note page

A note whose front matter says type:, such as a decision or an incident, shows its fields on the note page, under the page’s bar, one to a line, the key muted and in monospace, then its values. A person or a related row is a link by its title, which opens its page. A hub note opens as its tag’s page instead, so a person’s or a team’s fields are shown on its tag’s page, in the same rows.

• Its own fields come first: those the note writes, in the type’s order, then its other front-matter keys. The empty ones are left to the form.
• From other notes heads the fields other rows give this one, its reverses, in italics. Each says under its values where it is set, so you know which note to change: Set in each person’s manager when several rows set it, Set in Payments’ lead when one does. A field the note writes that other rows fill too says Also set in ….
• The type is named on the hub line, or, for a row of notes, above the fields; it opens the type’s rows.
• Edit fields…, after the fields and in ⋯, opens the form on the note. A field’s name, drawn as the key and underlined when pointed at, opens it at that field. A field from other notes is changed in the note its line names.

With a row’s note open, the Context view lists, under its related notes, the other rows of its type that share a relation’s value with it: Other people, grouped by team Payments, manager Alex Rivera, and reverses such as works on Checkout v2, each group’s label opening its search. See Related Notes.

Fields on a tag’s page

A typed tag’s page is where a person’s, a team’s, or an area’s fields are shown. Its hub card draws the hub note’s fields as the Note page does: its own first, then From other notes, each saying where it is set. Edit fields…, beside Open in the card’s header, opens the form on the hub note, and a field’s name opens it at that field. Open the page from the tag: Cmd/Ctrl-click @noor-haddad in a note, choose it in Find, or open the hub note, which opens its tag’s page.

A row with no hub note gets a Fields card in the hub’s place, its type named at the right:

• No note describes @alex-rivera yet. and Add fields…, which opens the form for its hub note, its title and tag filled in and kept; Create the note writes it with the fields you set.
• From other notes: what other rows say of it, each with who is behind it besides this row and where it is set: lead of: Payments (on-call Sam Okafor), Set in Payments’ lead. A detail that names only this row is left out, and one that names it among others names the others, (also decided-by Theo Park). So the page of an area no note describes still says who owns it.

Create hub note stays under the title, and opens the same form.

Asking Find

In a workspace with types, Find reads what you type as a row and a field, in either order, and lists up to three answers first, under Answer:

In a trading desk’s notes, bond trading lead walks the same way, from the Bond Trading area through Rates, the team that owns it, to its lead.

• The row is a run of words that is a row’s title, tag, or alias, without case, hyphens, or a trailing s: checkout, payments, alex rivera. Failing that, one word of its name will do: the first word of its title or a part of its tag, noor or haddad for @noor-haddad. When that word fits two rows, two Noors, each gets one answer.
• The field is the rest, after words such as who, is, and the: a field’s name, its reverse’s, or a word it is also called. When the row has no such field, Deckard looks through its relations and reverses, up to two away, and takes the nearest.
• A field that says what its row does, such as owns, asked of a row it names, is read from the other side: Checkout has no owns, so who owns checkout is the team whose owns lists Checkout. A field named for a role, such as lead, is not: checkout lead is the lead of the team that owns it.
• Enter opens the answer’s page, or, for a value written as text, the page of the row that holds it.
• A typed tag under Tags leads with its type and one fact: Team · lead Alex Rivera · 4 notes · 1 task.

In the editor

• Completions. In a row’s front matter, a new line offers the type’s field names. After lead: , the rows the field can name, each described by its type and first relation (Noor Haddad, Person · team Payments), or a select’s options, or true and false; each is written as Deckard writes it. In a type note, the Kind column offers the kinds and the type names, and rows: the namespaces in use.
• Marks. A value that names nothing, a value that does not fit its kind (date: soon), a field whose name a search already uses, a field two types define differently, and a relation the two sides disagree on are marked as Information, with deckard.editor.linkDiagnostics. Quick fixes offer Change to @omar (Omar Haddad) or the closest options, Create person “Omar H”…, which opens the form with the title filled in, and, in a type note, Allow Area or System and Create a System type.

• The first line. The one problems lens counts them, 2 unresolved, and selecting it shows them. The hub progress lens leads with the row’s type and first relation, *Person · Payments

  1/3 done (33%)*, and a row of notes gets that lead alone.

• Hover. A typed tag, or a [[link]] to a row of notes, names the row, its type, and its first text field, Noor Haddad @noor-haddad · Person · Senior engineer; then its relations and reverses, how to reach it, how much the notes say of it, last mentioned today · 2026-10-08, and Open @noor-haddad, Open Noor Haddad.md, and Copy email. Other tags hover as before.

Searching by field

The query language reads a type’s fields by name, after its own fields:

A search lists the notes and tasks in the rows’ notes, and, for rows of a namespace, everything their tags are on; a type’s rows tab lists the rows. A field name no type has is still an error, which names the fields you may have meant. A type = that names no type reads as kind =, as it did before types.

After type = team, the search box offers the type’s fields, its reverses, and its computed fields, then its relations’ fields, lead.email; after a field, its values: rows, options, true and false, or dates. Builder lists them in groups: the type’s own under its name, then Through lead and the like, then Built in.

In query blocks

noteColumns= in a query block takes a field, a path, a reverse, or a computed field, headed as you write it, read from the row each note is, or else the rows its tags are. this is the note the block is in, in the editor, the Markdown preview, the note page, and Copy as Plain Markdown. The work sample’s Checkout v2 lists its decisions:

```deckard view=table noteColumns=date,state,decided-by
type = decision AND project = this
```

For assistants

deckard_describe_tag (Describe a Deckard tag and its fields) takes a tag, a title, or a few words naming a row and answers in plain text: its type, title, tag, and note, or No hub note.; each field and its values; its reverses and what they come from; its open tasks; and its latest entries with their dates. deckard_query takes the new fields, and it and deckard_list_tags name the workspace’s types and their fields. See AI assistants.

Zen

← Writing notes: tags, people, and links · All topics · Tasks →