Apps and a filesystem. You need both.
Nobody buys a computer to use a filesystem. They buy it to run apps. But the filesystem is why the apps can exist, share data, and be replaced. TreeOS is both. The structured extensions are applications. The free-form tree is the operating system.
The kernel provides structure. Extensions provide applications. The user provides shape.
Twelve fields on a node. Seven fields on a user. A metadata Map that grows anything. A conversation loop. 29 hooks. A cascade engine. This is the filesystem. It doesn't know what a workout is. It knows what a node is.
Food, fitness, study, recovery, kb. These are the applications. They give the tree modes, tools, and structure. They parse domain-specific input. They track domain-specific values. They make the tree useful for a specific thing.
Free-form. You create nodes the extensions don't know about. A Supplements node under Food. A Swimming node under Fitness. A personal journal branch with no extension at all. Just notes on nodes. The AI reads them without any extension owning them.
The structured extensions work better because they have specific prompts, specific tools, specific parsing. The free-form path works because the kernel handles any node. Both live in the same tree. Both are nodes with notes and metadata.
Extension installed. Mode override set. Tools available. Parser active.
"bench 135x10" → parsed by fitness extension → routed to exercise node → values tracked (weight, sets, reps) → progressive overload calculated → coach responds with context
No extension claims this position. Default mode. AI reads context and talks.
"bench 135x10" → stored as a note → AI can read it → no special tracking → no routing → no overload logic
Most people will use extensions 90% of the time and free-form 10% for the things no extension covers yet. That 10% is where the evolve extension watches and proposes new ones.
The routing problem feels complex if you think from the message. "What does the user mean?" That's infinite. You can't classify every possible human utterance.
Flip it. Think from the position. The user is standing somewhere. That somewhere has a mode. The mode has a prompt. The prompt knows how to handle messages at this position. The message doesn't need to be classified. The position already classified it.
User at /Health/Fitness: "bench 135x10" → fitness knows what this means "how am I doing" → fitness knows what this means "I feel tired" → fitness knows what this means "what's for dinner"→ doesn't belong here. route out. User at /Life (root): "bench 135x10" → routing index finds fitness "how am I doing" → ambiguous. librarian reads tree. "what's for dinner"→ routing index finds food
At a specific position, 90% of messages make sense there. The mode handles them. The 10% that don't belong get routed out. At a general position like the root, most messages are ambiguous. That's where the routing index and librarian earn their keep.
Most messages resolve at step 1 because the user is at a position with an extension. The rest cascade through the steps. The system doesn't need to understand every possible human utterance. It needs to know where the user is standing.
The user doesn't choose between these explicitly. Position and command determine which one fires.
The apps get people in the door. The free-form tree lets them go beyond what the apps imagined. The kernel ensures both work through the same twelve fields and the same resolution chains.
Don't choose between structured and free-form. The structured extensions are what people use. The free-form tree is why they can reshape it. The kernel is why both work. All three layers. That's TreeOS.
Stop trying to design for every mode of being. Design for position. The modes of being emerge from where people stand in their tree.