Develosaur

A node has a title, a markdown body, tags, a value score, an effort score, a colour and a size. A note and a task are the same record, so nothing is ever converted into anything else.

Headings, tables, code fences, images. Paste a spec in and it stays a spec. Export is not a feature waiting to be built, it is what is already stored.

A node can present as a task list, a rich text page, a deadline, an image or a table. The shape changes how it draws itself, never what it can hold or where it is allowed to sit.

Dates are a directive inside the markdown rather than a column on the record. A node picks up a deadline without changing into a different kind of thing, and loses it the same way.

Position and size live in their own maps, not on the node. Rewriting a whole node for a drag pushed around 80 KB per move, and live updates were dropped on the floor.

Work leaves the board completed or deleted. There is no archive. Completed work leaves the canvas and stays readable in its own list, and delete is a permanent cascade that asks before it takes a subtree.

A thought with no home yet lands as a rogue node: on the board, out of the tree, waiting in its own strip until you drag it somewhere or an agent files it.

Where a node sits is its classification. There is no second taxonomy running alongside the tree, so no folder can disagree with a label.

Parentage is stored as edges, never as a field. Creating a second parent edge removes the first, and a repair pass settles it if two writers ever merge into a fork. A tree that can quietly become a mesh is a tree you stop trusting.

Drag a branch and every surface updates at once: the canvas, the ranked list, the kanban columns and what your agent reads on its next call. Nothing was filed twice, so nothing has to be updated twice.

The order inside a branch is deliberate and it is yours. It is stored as a fractional rank, so moving one card writes one node, and the derived part of the TODO list reads exactly that order.

Link a node from inside a sentence and it renders as a chip carrying that node's current title. Rename the target and every mention follows, because the link points at the node and not at a copy of its name.

Mark a branch informative and everything beneath it inherits that: readable, updatable, and permanently outside the work pipeline. The write gates refuse to complete or delete anything inside it.

Top down, bottom up, left to right, right to left, folder explorer and a radial mind map. Manual positioning was retired on purpose: the layout decides where a card sits, so the picture is never a stale arrangement nobody has tidied.

Expanding opens exactly one level and re-folds what it reveals, so a board never explodes in your face. Folding writes nothing to the document and is remembered per project on your own machine.

Cards become capsules and then circles as they cross readability thresholds measured in screen pixels. The shape of the project survives at any zoom, instead of turning into unreadable mush.

Scope the board to one branch, or to the work one agent currently holds. A lens lives in the URL and never mutates a node.

Undo and redo are shown as lanes you can jump into rather than a key you tap hopefully. Restoring an earlier version takes a safety snapshot first, so going back is itself undoable.

Markdown with a slash menu, mentions that link other nodes, images in the body and a lightbox to read them at full size.

Exact text, by meaning, neighbours of a node, recorded decisions, and where a new node belongs. One call with a mode, not five different searches to remember.

Substring over titles and bodies needs no index, no account and no model. It is the default, and it is the mode that still works on a board opened with no account at all.

Meaning based search embeds text with a 25 MB model in your own browser. No API key, no third party, and the query is embedded the same way the content was.

The index watches the document and re-embeds a node shortly after you stop typing. Unchanged text is skipped by content hash, so re-indexing is cheap and repeated saves cost nothing.

Write a Decision heading in the body of the node it affects and it is indexed as its own chunk. One call returns every decision on the board, or the ones nearest a topic.

Filtering expands any folded branch containing a match, then restores your fold state when you clear it. A filter that highlights only hidden cards looks broken exactly when it has found something.

A node reaches the TODO list only if it carries a tag, has a deadline, or is already in progress. Untagged thinking stays on the board and stays searchable, without queueing itself up as work you have to triage.

A tag can hold an instruction block that every agent reads before acting on a node carrying it. Write the rule once, and the server quotes it back at an agent whose write breaks it.

A tag can keep a node out of priority, mark a branch as reference, or act as a workflow state. Three effects, and the last two cannot both apply to the same tag.

TODO, IN-PROGRESS, VALIDATE, COMPLETED, BUG, CRITICAL and REFERENCE come with the board, each with its own colour. BUG describes what a thing is and survives completion; the workflow tags move a node through the pipeline.

The kanban board is not a second copy of your work. Each column is a tag, and dropping a card does tag arithmetic that leaves every other tag on that node alone.

Directed: a blocker points one way, A before B, never back. Acyclic: wire A behind B behind A and the write is refused by name before it ever saves. Graph: nodes are tasks, edges are the blockers between them. It is the exact structure Bazel builds code on, Airflow and Cloud Composer run data pipelines on, and Vertex AI Pipelines chains a training run through. Different job, same shape.

A node with an unresolved blocker, or an unresolved child, is not ready, full stop. That gate runs before scores, before tags, before anything typed into a priority field. The graph decides what CAN happen. The ranker only decides what happens first among what can.

If B and C both wait on A, finishing A frees both in the same read, and neither needs an order relative to the other. That is the ready set. Different agents claim different entries from it at once, each under its own lease, so two agents never collide on the same task.

When everything in scope is blocked, the frontier does not just say so. It names the specific blocker holding back the most other work, so the question is never what to unblock. It is already answered.

Every node carries the ids of the nodes blocking it, and a parent can also wait on its own unfinished children. Because it is structured rather than prose, the ranker can actually read it.

Wire A behind B behind A and the write is rejected with the exact chain it would have closed. You cannot save a plan that can never start, which is a better error than a plan that looks fine and stalls in week three.

This is a hard pass over the finished list, not a tie break. Nothing is exempt: not the head you pinned, not the work already in progress. An order that puts a task above what it waits for is a lie about what can be started.

In progress first, then overdue, then the head you pinned, then everything else derived from the tree in your own sibling order. The same board always produces the same list, for every reader and every agent.

Value is a tie break. Effort never orders anything; it estimates days. The additive score formula that used to rank the board is gone, and sibling order is the lever that replaced it.

An agent asks for what is takeable: unblocked, unheld, a leaf, and inside its work window. An empty answer explains itself and names the blocker holding back the most work, so there is always a next move.

Beyond parents and blockers, the board derives semantic edges from the content itself, each with a confidence, kept in their own layer. A guess must never be able to quietly rewrite the hierarchy you built.

Every board is a single Yjs document. Nodes, edges, sizes and drawings are top level maps, and each node is its own map edited one field at a time. Merging is the CRDT's job, not a save button's.

Two writers on the same node merge field by field, and the later write to a given field wins. There is no document lock and no check out, so an agent and a person can work the same branch in the same second.

The document is cached on your machine and unsent writes wait in a durable queue. On reconnect the client catches up from where it left off and merges. A dropped connection costs you time and nothing else.

Starting a task claims it for 45 minutes. A second agent is refused by name and told who holds it and for how long. Leases cover tasks, never files: your repository is not the board's business.

Field level merge resolves silently, so the board watches for two writers touching the same field within 30 seconds and raises a notice. It is a notice, not a merge dialog: you are told, and you decide.

The live channel carries only a wake signal saying new writes exist. Clients then pull the bytes they are missing. Broadcasting every change cost 6.7 GB of traffic in eight days of one person working alone.

Writes append as rows and roll into a snapshot after 50 of them or an hour of quiet. A per writer ceiling of 240 rows a minute keeps one runaway client from flooding a board everyone else is reading.

Read with review_tree, read_nodes, find and gather_context. Write with grow, create_nodes, update_nodes, move_nodes, delete_nodes, capture and attach_media. Drive state with prioritize, complete_nodes, edges, tags, projects and handoff. There is no verb that returns the whole board at once, and that is on purpose.

A markdown outline is the whole payload: heading depth is tree depth, and the lines under a heading become that node's body. The same grammar builds a branch over MCP, over REST, and from a shared link, so there is one thing to learn.

The host on your own machine and the cloud gateway are one package exposing the same verbs. They report their version on a health endpoint, so drift is something you can see rather than something you discover.

A stranger's agent can build a real board in about a minute with no account at all. That anonymous surface is a strict subset by design, so a verb working on the desktop and not in the sandbox is usually correct rather than broken.

Every verb has a plain REST route, the agent manual is served as llms.txt on both wires with no auth, and the machine readable schema is generated from the routes the server actually dispatches on.

An agent authorises itself: it shows a short code, you approve it in your browser, and it carries on with your real boards in the same conversation. Agents are told never to ask you for a token and never to write one to a file.

Completing refuses a node that carries no tag and no evidence, and the refusal explains the rule. It is enforced at the verb rather than written in a document nobody reads.