* Log message to stderr (for debugging, not protocol communication)

Push a new binding

Advance to next character

Create a variable term

Insert WHNF result

Create an application term

Advance to next token

Check if current token matches

Get a term by its ID

Process a RAG query with policy verification

Expect a specific token

* Demonstrate hash-consing: creating same term twice reuses memory * Returns true if successful * @param {number} index * @returns {boo

Create a sort term

Intern a term and return its ID

Get the kind of a term by its ID

Parse an expression

Get the span of this expression

Combine two spans into a single span covering both

1. Spawn: Create new agent (<500ns target)

Spawn a new agent

Start the runtime

Get the zero level ID

Get current character

* Initialize AgentDB connection

Create a natural number literal

Receive message (async)

Stop the runtime

Intern a term into the hash-consed arena This computes the canonical representative [t]≡ ∈ T̂ Complexity: O(1) amortized

Parse an identifier

Add an episode to memory

Get the length of this span

Create a max level

Send message with backpressure check Returns error if above high water mark.

Get cache statistics (demonstrates hash-consing benefit)

* Create a lambda abstraction (x : Type) => x * @returns {boolean}

Create a constant term

Create a lambda term

Compute parallel reduction of a term This is a single-step reduction that reduces ALL β-redexes simultaneously. For example: - `(λx.x) ((λy.y) z)` ⇉

* Test helper

Update profile with new execution data

Check if at end of file

Push a simple variable binding

* Send a JSON-RPC request

Synthesis mode: infer the type of an expression Returns (term, type)

* Wait for specified milliseconds

Get current token

Create a Pi term

Add a robot

* Close database connection

Get a level by its ID

Get the number of interned symbols

Push a new binding onto the context

Normalize a term to WHNF

Add agent to topology

Checking mode: check that an expression has a given type

Create a concrete level

Create a fresh metavariable

Intern a level and return its ID

Check if two terms are definitionally equal

Parse function parameters

* Send JSON-RPC response

Add a safety zone

Execute financial action with proofs

Execute control command with safety verification

Create a fresh metavariable

Get the term's hash

Check if at end of input

Pop the most recent binding for a name

Recall episodes with explanation

Run the task

* Send JSON-RPC error

Unify two terms

Verify Ed25519 signature