Four years of research.

Append-only behavioral type kernel — types and values as one continuum.

The first crystallization (2026): types that carry deadlines and confidence (P(done ≤ deadline) ≥ conf), time-conditioned gap priority, RBAC derived from state, and backward tool search. Mined, not run.

One lattice, one operation (insert), every feature an installed rule.

The decided semantic kernel Shared Office is built on: constraints-as-data, one generic evaluator, where-gated blocks that suspend and watch, belief distributions with Bayesian updates, commitment election, and the mutual-rendering planner. Backlinks, gates, budgets, scheduling are all mounted rules — not kernel code.

A CUE-inspired structural type system that doubles as a reactive rule engine.

The type IS the fold function — no separate ORM or query engine. Carried belief-suspension, the draft/preflight/gaps lifecycle, and read-visibility as a type-level concern. The “type = fold” thesis sequence later subsumed.

A constraint-propagation kernel over multi-dimensional anchors — one kernel for access control, typing, gates, and lifecycle.

Three-valued verdicts (met / unmet / undetermined) with a per-verdict policy — continue, preempt (kill the change), or hoist (escalate a suspended judgment to the scope that owns its resumption). Proved hoisting is its own rule.

Event orchestration across agents and users — the original working Office Space.

The end-to-end proof that memory, calendar, scheduler, and context-window are four projections of one append-only fact space. Server, permanent agents, env adapters (unix / docker / lambda / browser), bilateral gap exchange over WebSocket — the shape the shipped product re-materializes.

Declarative temporal constraint evaluation — identity-keyed resource budgets that discover their own dependencies and commit atomically.

The literal “guardrail” of the thesis: forecasting and control of token consumption across a shared plan, fail-closed and all-or-nothing. A law's read-set is derived, not hand-listed.

A hoist-aware compiler that treats budgeted rendering as constrained optimization, not truncation.

Where we learned budgets are prices, not caps: for every shared sub-expression, inline at each use or hoist once and reference — chosen to maximize fidelity under a cost cap, with elision priced, never silent. The engine behind token-budgeted prompt and brief composition.

Turns a typed value into a running, addressable, snapshotted, subscribable process — without inventing a new primitive.

Pure glue wiring three packages that know nothing about each other. Two findings: persistence IS subscription (one dispatch), and a type's constraints ARE its schedule (operational policy lives in the contract).

Typed, event-emitting, subscribable long-running computations — addressable and controllable (pause / resume / cancel / seek).

The liveness substrate beneath shared spaces, with retention so late subscribers get the replayed tail. Sharpened a core distinction: suspending an execution (a parked generator) is a different rule from suspending a belief.

An event-sourced version-control engine generic over content type — patch log is truth, reads are nearest checkpoint plus forward replay.

Built for stateless serverless (not Git, CRDT, or OT). Proved deterministic replay is a provenance rule — same log, same content — with hot/cold storage tiering. The persistence spine under versioned state.

A polymorphic interface for version control over arbitrary data — every type implements the same five operations.

The witnessed-mutation primitive: a mutation transparently commits a patch and its inverse. That inverse is the retraction / belief-revision prerequisite the whole synthesis still rests on.

A versioned cell composing a patchkit type, the source engine, and namespace addressing.

A cautionary fossil: cell was later deleted for re-implementing the substrates beneath it. That deletion is the “no fourth primitive” discipline now load-bearing in the architecture (process IS the cell).

Companion utilities for sequence — agent loop, indexSpec policies, base tools, WebSocket transport, React hooks.

Keeps the kernel lean; pay for what you import. Its agent loop (hoist → LLM → violations → gaps) is the reference for what a substrate must render for an LLM to self-correct — and informs the ambient team brief.

A pushdown parser whose grammars compose at runtime — a guest language parses on the host's stack, no sub-parsers.

The mechanism behind “features are vocabulary”: you extend one grammar by registering transitions into a shared table, not by building a new engine. Built to embed templating/meta-languages into markdown or JSON.

A multi-format composite path grammar — one engine walks paths, streams, and cross-regime references.

The single addressing primitive for a multi-dimensional lattice (structure, time, identity, partition, stage, type). The shipped `as` operator is its single-boundary special case.

A heap-based probabilistic decision-tree executor — evaluate next whatever prunes the most expected work.

Recovered the rule that inference order is itself a judgment under budget (weight = expected work pruned). The in-kernel echo is `office gaps`, ranked by what each unknown blocks.

A path-based tree-walker — register handlers on dotted paths, walk once, get per-path callbacks.

A corroborating echo of indexSpec: one-pass multi-path extraction with subscriptions-as-handlers, O(n) instead of O(n × paths).

A multi-dimensional temporal artifact index — address anything across identity, version, and stage in one path.

Taught the version-pin vs. live-stage distinction with fallback chains (LIVE → INTEG → STAGING), now articulated as `topic@seq` pins vs. head semantics. Indexes declared as metrics, not schemas.

Multi-dimensional addresses — one stable anchor plus N per-dimension coordinates, round-trippable as a compact string.

Seeded the interpretation-carrying address ({ server, uri, as }) and per-caller dimensional projection — audience-projected identity, the reader applied to naming.

A dictionary-based structural codec with delta encoding, a graph bundler, and a hoist/inline code generator. Zero deps.

Independently re-derived the hoist-vs-inline decision first seen in compile — confirming that rendering under a bound is a universal operation. Measures encoding cost per value, not per type.

An observable/promise hybrid — a late-bound value that resolves like a promise but fires repeatedly and replays to late subscribers.

The live-push / subscriptions-as-state pattern; replay plus demand-gated dequeue prefigure flow-controlled fan-out — the lesson a WebSocket fan-out defect later paid for in production.

Collection structures distinguished by referencing and observation — observable queues, index maps, heap maps.

Handle-based identity and in-place priority update() — the reusable idea behind schedulers, subscription registries, and reactive UIs.

Minimal list / set / heap multimaps — order-preserving, deduped, or priority buckets behind one API.

The recurring “each key holds a collection” need (event → handlers, entity → tags, key → priority queue), without re-rolling per-bucket bookkeeping.