The Brain.

packages you'll see in `node_modules`

• @kashscript/neuronrequired

  Kernel, schemas, handshake, ledger, decomposer, judge, orchestration.

• @kashscript/identity-coretransitive

  Signing — every Kash-Event in the ledger is Ed25519-signed.

• @kashscript/lexiconstransitive

  Envelope schemas for `kash.neuron.*` records.

peer dependencies · install in your project

• zod@^3.23.8All wire-level schemas (AgenticSpec, TaskDAG, Receipt, ToolManifest) validate with Zod.required

outside npm · what else you need

• An LLM provider

  Neuron is model-agnostic — bring OpenAI, Anthropic, Bedrock, local Ollama, vLLM, or your own. The `LLMProvider` seam is a 4-method interface.

  # pick one — bun add openai  | bun add @anthropic-ai/sdk  | bun add ollama

• (optional) Postgres / Supabase

  For durable `StateStore` + `ReceiptStore`. In-memory variants ship by default — production hosts wire their own backend.

  # Postgres on your platform of choice, OR `bun add @supabase/supabase-js`

framework wiring

import { LifecycleManager, PostgresStateStore, PostgresReceiptStore, ReceiptWriter } from "@kashscript/neuron";

const manager = new LifecycleManager({
  stateStore:    new PostgresStateStore({ pool }),
  receiptStore:  new PostgresReceiptStore({ pool }),
  nonceStore:    new InMemoryNonceStore(),
  // ...
});

app.post("/agent", async (req, res) => {
  const { executionId, dag } = await manager.genesis(req.body);
  res.json({ executionId, dag });
});

// supabase/functions/agent/index.ts
import { runHeadless } from "@kashscript/neuron/deployment";

Deno.serve(async (req) => {
  const { intent, spec } = await req.json();
  const result = await runHeadless({ intent, spec, secrets: Deno.env.toObject() });
  return new Response(JSON.stringify(result), { headers: { "content-type": "application/json" } });
});

kash neuron status           # health check
kash neuron audit            # tamper-detection self-test
kash neuron oreoasis-status  # verify Oreoasis plugin loads

troubleshooting · the support inbox

• ▸ `No LLMProvider configured` thrown on `manager.genesis(...)`.

  Wire one in the `LifecycleManager` constructor. The shipped IdentityAdapter handles signing; you bring the model. Examples for OpenAI / Anthropic / Ollama are in the `neuron-claude` / `neuron-openai` / `neuron-ollama` adapter packages (roadmap; until then, implement the 4-method `LLMProvider` interface inline).

• ▸ `ENVELOPE_REQUIRED` from `ToolConnector` on a tool call.

  The tool's scope is `restricted` in the skill manifest and the call lacks a signed action envelope. Either issue an envelope via the Phase-2.2 handshake, OR widen the scope in the manifest (carefully — restricted scopes exist for a reason).

• ▸ `SIGNATURE_FAILED` on `manager.hydrate(executionId)`.

  A receipt in the chain has been tampered with — either DB corruption, malicious write, or a key rotation that wasn't replayed. Run `kash neuron audit` to surface the precise `breakAt` index. Recovery is manual; do not retry blindly.

• ▸ MCP transport times out (10 s deadline).

  The dispatched tool exceeded the hard deadline. Either optimize the tool, OR push it behind an async queue + return a job-id pattern. The 10 s cap is non-negotiable to prevent zombie processes.

• ▸ Privacy filter scrubs values you wanted to forward.

  The filter pattern matches anything that looks like a DID / SSN / 64-hex private key. Tune the `privacyFilter.allowlist` in the `LifecycleManager` constructor for fields you explicitly trust to leave the boundary.

• ▸ Adversarial Judge keeps rejecting valid outputs.

  The judge runs three independent audits (hallucination / character-drift / schema). Inspect the rejection reason in the receipt — if it's a false positive on a niche domain, tighten the `skillManifest.outputContract` so the schema axis stops triggering.