Organism Complete Code and Operations Bible v1.0

Part I: Canonical Doctrine

SOURCE CLAIM: snapshot July 16-17, 2026. Status at that date: integrated with final durability blockers, not yet ratified.

1. Founding definition

Neuruh is a sovereign, modulated agentic opportunity organism. It continuously senses fragmented signals across people, property, businesses, markets, technology, physical assets, knowledge, and human workflows; converts those signals into evidence-backed opportunity models; dynamically composes the right agents, models, tools, memory, policies, and interfaces for the environment; and executes the strategy that creates, captures, protects, or compounds value.

Public-safe definition: Neuruh finds hidden value before the market recognizes it, proves where that value exists, and deploys the systems required to capture it.

2. Convergence program, not a greenfield build

The estate already contains substantial architecture, repositories, agents, products, receipts, data, and bounded autonomous behavior. The current program is canonicalization, integration, validation, supervision, and completion. New named platforms are prohibited unless an explicit architecture decision proves that the existing organism cannot absorb the requirement.

• Preserve: SAL, PMLA, AXON, MOTHER, FATHER, AEGIS/IAR, Galaxy, Worlds, revenue spine, knowledge spine and t0-t6 lanes.
• Consolidate: duplicate routers, duplicate memory planes, duplicate health authorities, overlapping orchestration brands and status vocabularies.
• Finish: live process replacement, migration 038, memory custody reconciliation, durable supervision, platform preservation and final canaries.
• Do not invent: another organism, another AXON, another AEGIS, another Vault, another cockpit or another receipt system.

3. Non-negotiable doctrine

• Evidence precedes confidence.
• Repository truth outranks documentation claims.
• No unsupported fact, silent conflict resolution or status inflation.
• Deterministic arithmetic outranks model-generated arithmetic when deterministic code exists.
• Human approval is mandatory for external sends, production writes, spending, deployment, push, deletion, credential changes and schema promotion.
• Every action that matters produces a receipt with inputs, authority, evidence, code identity, outcome and rollback.
• Learning follows propose, test, shadow, canary, promote, with rollback at every stage.
• Sensitive and PII-bearing material remains local and access-scoped.
• A product is a sensor, organ, recipe, interface or emitter running on the shared organism.

4. Status vocabulary

Part II: Organism Architecture

5. Canonical closed loop

6. The two spines

7. t0-t6 execution lanes

The lane model describes execution placement. It does not replace the protected organism anatomy. t0 is the accountable human operator; t1 contains deterministic engines; t2 contains canonical knowledge; t3 contains AEGIS/IAR; t4 emits bounded Worlds and products; t5 is CRM and relationship workflow; t6 is the cockpit and observable command surface.

8. Protected components and responsibilities

9. Products and domains

Every product is a cut through the organism. Internally, breadth is preserved as reusable sensors, organs, recipes, interfaces and emitters. Externally, each World is sold as a narrow outcome.

Part III: Runtime and Repository Truth

10. P1.1 snapshot, July 16, 2026

11. Canonical repository root and worktree doctrine

~/neuruh-repos/NeuruhAI/
~/neuruh-worktrees/
~/neuruh-workspace/
~/neuruh-workspace/audit-output/

• Do not use iCloud-active repositories.
• Every code change occurs on a dedicated branch or worktree.
• Shared dirty worktrees are never cleaned by another terminal.
• A local-path fetch may import a branch between duplicate clones, but the imported SHA must be verified before merge.
• Main, origin/main, deployment and production state do not move without explicit operator approval.

12. Service and port map

13. Source-of-truth hierarchy

6. Live process provenance, semantic health and execution receipts.
7. Git commit, branch, worktree state and tests.
8. Database schema and migration history.
9. Canonical contracts and manifests.
10. Vault source corpus and SHA-256 identity.
11. Notion canon and approval records.
12. Historical transcripts, plans and narrative documents.

A newer document does not automatically outrank an older verified commit. A newer file may be a copy of stale content. Freshness must be established from content, commit identity, process CWD, timestamps, hashes and receipts together.

Part IV: Governance, Trust and Human Authority

14. Authority intersection

The executable authority is the deterministic intersection of what the system proposes, what policy allows, and what is currently available:

effective = proposed & allowed & available
blocked   = proposed & ~effective

No model instruction, prompt override, direct route or missing credential may expand effective authority. Unavailable capabilities fail closed. Policy is checked before execution and again at the final write or send boundary. Try it in the Explorers tab.

15. Non-negotiable human gates

16. Governed executor contract

• Realpath-authoritative worktree containment.
• Hard denylist for production targets that wins even over an approved root.
• Content-bound approval: target path plus SHA-256, not blanket approval.
• Exact argv allowlist and execFile; no unrestricted shell.
• Read evidence, propose, approve, guard re-check, write, read back, verify SHA-256, run allowlisted test, append receipt.
• Required rejections: traversal, outside-worktree, symlink escape, missing approval, production target and unapproved command.

17. Receipt doctrine

Receipts are not decorative logs. They are the proof that binds objective, evidence, topology, authority, code identity, tests, action, outcome and rollback. Receipt chains are append-only and hash-linked from GENESIS. A receipt that cannot verify is evidence of a break, not a status to be ignored.

Part V: Memory, Learning and Corpus Custody

18. Canonical memory roles

19. Shared document identity

The same canonical document identity and SHA must travel across the Vault, AnythingLLM, Qdrant, retrieval citations and receipts. The ratified identity observed in the current corpus is:

document_id     = "doc_" + sha256(vault_relative_path)[:16]
qdrant_point_id = int(sha256(document_id)[:15], 16)
content_sha256  = sha256(file_bytes)

Legacy UUID5 identifiers remain as cross-references where they exist. They are not silently rewritten in live indexes. Any identity conflict is recorded and resolved through an explicit migration or canon amendment. Try the identity calculator in the Explorers tab.

20. Current Galaxy reconciliation

21. Learning is outcome-linked promotion

Memory is not learning by itself. Learning requires a closed loop in which a prior outcome changes a later topology or ranking, the change is evaluated, and the improvement is verified. The promotion sequence is:

propose -> test -> shadow -> canary -> promote
                        \-> rollback at every stage

• Store both successful and failed topologies.
• Preserve counter-evidence and superseded claims.
• Measure task success, economic outcome, governance violations, cost and latency.
• Do not claim organism-wide self-improvement until a verified feedback event changes a future run and improves it.

Part VI: N-Cell Theory and Mathematical Basis

22. The original geometric observation

A byte contains eight binary positions with weights 128, 64, 32, 16, 8, 4, 2 and 1. A custom coordinate key can assign each position to a point or direction. The corrected right-angle mapping uses points on y = 8 - x and y = x, meeting at (4,4).

P(p) = (p, min(p, 8 - p))
W(p) = 2^p
p in {0,1,2,3,4,5,6,7}

The vectors from C=(4,4) to A=(5,3) and B=(3,3) are (1,-1) and (-1,-1). Their dot product is zero, so the angle at C is 90 degrees. The mathematics is standard; the potentially distinctive contribution is the Neuruh control contract built on top of the encoding.

23. Eight-neighbor topology

The strongest operational interpretation assigns one bit to each local direction or connection family. One byte then describes which edges are active at a node. Storing directions clockwise creates a real geometric relationship: rotating the byte one position corresponds to a 45-degree topology rotation; two positions correspond to 90 degrees; four positions correspond to 180 degrees.

rotate45(mask)  = ROL8(mask, 1)
rotate90(mask)  = ROL8(mask, 2)
rotate180(mask) = ROL8(mask, 4)
delta           = previous XOR current

24. What N-Cell is

N-Cell is a proposed runtime ABI and control-plane fingerprint for the existing organism. It gives separate repositories the same answer to what was active, connected, authorized, available, blocked, remembered, completed and emitted. It does not store the full semantic record or replace the systems that created the evidence.

25. The highest-level hypothesis

The dominant AI hypothesis optimizes the model. Neuruh proposes that system-level intelligence is also a function of the computational organization assembled around the objective: topology, authority, memory, evidence, tools, economics and output contract. N-Cell is the instrument that records those variables consistently.

Outcome Y = F(Model M, Topology G, Tools T, Authority A, Memory R, Evidence E)
Most systems optimize M.
Neuruh also measures and optimizes G, T, A, R and E.

Part VII: N-Cell/64 Contract

26. Eight coordinated bytes

27. Example organ and authority bytes

Organ byte
Bit 7 Security
Bit 6 Memory
Bit 5 Routing
Bit 4 Composition
Bit 3 Governance
Bit 2 Execution
Bit 1 Emission
Bit 0 Outcome

Authority byte
Bit 7 Inspect
Bit 6 Classify
Bit 5 Compose
Bit 4 Evaluate
Bit 3 Execute internally
Bit 2 Write externally
Bit 1 Spend
Bit 0 Human-approved

28. Required invariants

• Every mask is an unsigned byte from 0 through 255.
• The header is compiled from actual trace and receipt facts; it is not self-reported by a model.
• The first integration is observational: stripping the N-Cell field must leave the canonical result unchanged.
• Topology hashes are calculated from canonical JSON and detect mutation.
• Authority is the proposed/allowed/available intersection.
• N-Cell never carries secrets, raw PII or full evidence payloads.
• Bit meanings are versioned and cannot be redefined per World.
• Domain extensions use registries or additional banks rather than changing the core bytes.

29. Binding order

13. AEGIS parity wrapper: execute(request) versus executeWithNCell(request).
14. Bind the header into existing hash-chained AEGIS receipts.
15. Bind the same header into LandOS reproducible run manifests.
16. Bind approved World Emitter manifests.
17. Render current, previous and XOR state in the Cockpit.
18. Index topology-to-outcome history in the Vault after parity is proven.
19. Promote any behavior-changing topology optimizer only after shadow and canary tests.

Part VIII: Validation and Claims Contract

30. Six core hypotheses

31. Organism proof gates

32. Claims discipline

Part IX: Operations, Incidents and Terminal Custody

33. Terminal ownership at the current checkpoint

34. Incident discipline

• A failed stop command is not a successful stop. Verify process state after TERM and after KILL.
• Do not use killall against shared runtimes.
• Do not run a second writer against Qdrant, AnythingLLM, a shared manifest or a production database.
• Do not clear caches ad hoc when free space is low; record targets, hashes, size and consequence first.
• ENOSPC is a durability incident because it can corrupt manifests, kill services and destroy authenticated browser sessions.
• Every incident produces a command ledger, affected stores, counts, current state and remediation owner.

35. Controlled live sequence

1. Stop and receipt unauthorized memory work
2. Recover at least 10-15 GiB durable headroom
3. Swap IAR to 8ab0c59 and verify provenance + Ollama
4. Swap AXON-GW to 56b4f54 and verify governed tools
5. Apply migration 038
6. Run final live canaries against final PIDs
7. Controlled cold reboot
8. Read-only memory reconciliation
9. One approved ccT12 completion run
10. Ratify canonical baseline

36. Rollback doctrine

Every live change is performed one component at a time. Capture pre-swap health, process, CWD and commit. Stop cleanly. Launch from a verified clean worktree. Verify semantic health, receipt integrity and a harmless canary. Roll back immediately if the new process fails its contract. Never combine IAR, AXON, database and memory mutations into one unauditable event.

Part X: Platform, Subscription and Credit Gates

37. Gate classes

38. Immediate non-subscription gates

39. Reported provider and subscription register

40. Subscription doctrine

No subscription is renewed merely because it exists. Every provider must have an owner, system dependency, monthly cost, quota, renewal date, failure behavior, replacement option, data-export plan and measured revenue contribution.

No subscription without:
  owner
  dependency
  monthly cost
  quota or credits
  renewal / expiry
  failure behavior
  replacement option
  data custody / export
  measured revenue contribution

41. Funding order

20. Storage capacity and backup integrity.
21. Supabase data preservation and project survival.
22. Domain, DNS, email and Google Workspace identity impact.
23. Vercel only after a deployment inventory proves what should remain hosted.
24. Anthropic fallback budget with an explicit spend cap.
25. Twilio only when compliant outreach is ready to produce measurable revenue.
26. Unique property, GIS, DNC and skip-trace providers tied to one live workflow.
27. All other providers must prove return on investment before renewal.

Part XI: Ratification and Commercial Position

42. Finite path to canonical baseline

43. Honest classification

44. The commercial wedge

The first undeniable proof is not a broad AGI claim. It is one closed, repeated, profitable loop in LandOS/APG: signal, entity resolution, scoring, evidence, strategy, governance, human approval or execution, outcome capture, weighting/topology adjustment, improved next opportunity. The same substrate can then emit Worlds for service-business automation, resale, knowledge conversion and other domains.

Appendix A: Branch and Commit Ledger

Appendix B: N-Cell Reference Implementation

Code authority (source claim): The following code is a complete dependency-free reference implementation included in the companion ZIP. It passed 10/10 local Node tests during document generation. The canonical AEGIS branch remains authoritative until parity and receipt-binding tests approve a merge.

import { createHash } from "node:crypto";
export const UINT8_MAX = 0xff;
export const ORGAN_BITS = Object.freeze({ SECURITY: 7, MEMORY: 6, ROUTING: 5, COMPOSITION: 4, GOVERNANCE: 3, EXECUTION: 2, EMISSION: 1, OUTCOME: 0 });
export const AUTHORITY_BITS = Object.freeze({ INSPECT: 7, CLASSIFY: 6, COMPOSE: 5, EVALUATE: 4, EXECUTE_INTERNAL: 3, WRITE_EXTERNAL: 2, SPEND: 1, HUMAN_APPROVED: 0 });
export const LIFECYCLE_BITS = Object.freeze({ SENSED: 7, NORMALIZED: 6, RESOLVED: 5, SCORED: 4, COMPOSED: 3, GOVERNED: 2, EXECUTED: 1, MEASURED: 0 });
export const MEMORY_BITS = Object.freeze({ CANON: 7, VAULT: 6, HUMAN_RAG: 5, MACHINE_RAG: 4, EPISODIC: 3, BEHAVIORAL: 2, RECEIPTS: 1, OUTCOMES: 0 });
export const OUTPUT_BITS = Object.freeze({ REPORT: 7, CRM_STATE: 6, WORLD: 5, API: 4, DRAFT: 3, EXTERNAL_SEND: 2, PRODUCTION_WRITE: 1, ECONOMIC_OUTCOME: 0 });
export function assertUint8(value, name = "mask") { if (!Number.isInteger(value) || value < 0 || value > UINT8_MAX) throw new RangeError(`${name} must be an integer from 0 through 255.`); return value; }
export function bit(p) { if (!Number.isInteger(p) || p < 0 || p > 7) throw new RangeError("bitPosition must be an integer from 0 through 7."); return 1 << p; }
export function maskFromBits(ps) { return ps.reduce((m, p) => m | bit(p), 0); }
export function hasBit(mask, p) { assertUint8(mask); return (mask & bit(p)) !== 0; }
export function setBit(mask, p, active = true) { assertUint8(mask); const s = bit(p); return active ? mask | s : mask & (~s & UINT8_MAX); }
export function intersectMasks(...masks) { if (masks.length === 0) return 0; return masks.reduce((r, m) => r & m, UINT8_MAX); }
export function unionMasks(...masks) { return masks.reduce((r, m) => r | m, 0) & UINT8_MAX; }
export function changedMask(prev, cur) { return prev ^ cur; }
export function rotateLeft8(mask, positions = 1) { assertUint8(mask); const s = ((positions % 8) + 8) % 8; if (s === 0) return mask; return ((mask << s) | (mask >>> (8 - s))) & UINT8_MAX; }
export function rotateRight8(mask, positions = 1) { return rotateLeft8(mask, -positions); }
export function popcount8(mask) { let v = mask, c = 0; while (v !== 0) { v &= v - 1; c += 1; } return c; }
export function binary8(mask) { return mask.toString(2).padStart(8, "0"); }
export function activeNames(mask, registry) { return Object.entries(registry).filter(([, p]) => hasBit(mask, p)).map(([n]) => n); }
export function canonicalJson(value) { if (value === null || typeof value !== "object") return JSON.stringify(value); if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`; const keys = Object.keys(value).sort(); return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(",")}}`; }
export function sha256Canonical(value) { return createHash("sha256").update(canonicalJson(value)).digest("hex"); }
export function evaluateAuthority({ proposed, allowed, available }) { const effective = intersectMasks(proposed, allowed, available); const blocked = proposed & (~effective & UINT8_MAX); return Object.freeze({ proposed, allowed, available, effective, blocked }); }
export function buildNCellHeader(input) { /* validates routeMask, organMask, lifecycleMask, authorityMask, memoryMask, outputMask, confidence, risk; builds identity {schema:"neuruh.ncell/1.0", nodeId, runId, worldId, masks, confidence, risk, codeHashes, stateSchemaHash, previousTopologyHash}; topologyHash = sha256Canonical(identity); returns frozen header with topologyHash, observedAt and binary masks. */ }
export function verifyNCellHeader(header) { const { topologyHash, observedAt, masks, ...identity } = header; return sha256Canonical(identity) === topologyHash; }

compileNCellFromTrace(trace): derives organMask, lifecycleMask, memoryMask and outputMask from trace fact objects via enabledBits(registry, facts); authorityMask = evaluateAuthority(trace.authority).effective; then buildNCellHeader(...).
executeWithNCell(execute, request, compileTrace): runs execute(request), compiles the trace, returns { ...result, ncell }.
stripNCell(result): returns the result without the ncell field. Parity (H2) requires stripNCell(executeWithNCell(x)) to equal execute(x).

GENESIS_HASH = "GENESIS";
sha256Text(value): SHA-256 hex of the text.
sealReceipt(payload, previousReceiptHash = GENESIS_HASH): body = { schema: "neuruh.run-receipt/1.0", previousReceiptHash, ...payload }; receiptHash = sha256Text(canonicalJson(body)); returns frozen { ...body, receiptHash }.
verifyReceipt(receipt): recomputes the hash over the body without receiptHash.
verifyReceiptChain(receipts): checks previous-hash continuity from GENESIS and every receipt hash; returns { ok, count, head } or { ok:false, index, reason }.

BIT_COUNT = 8;
bitToPoint(position): { bit: position, weight: 2**position, x: position, y: min(position, 8 - position) }.
decodeShape(byte): eight points with an active flag per bit.
isRightAngle(pointA, center, pointB): dot product of (A-C) and (B-C) equals zero.

1. Full organ mask activates all eight organs: maskFromBits(all ORGAN_BITS) = 255, binary "11111111", 8 active names.
2. Authority is proposed AND allowed AND available: proposed 0b11111110, allowed 0b11111000, available 0b11111111 gives effective 0b11111000 (248), blocked 0b00000110 (6).
3. External write and spend can be stripped while internal execution remains.
4. Topology hash detects tampering: header verifies true; same header with risk 250 verifies false.
5. XOR records topology differences: changedMask(0b10110010, 0b10110110) = 0b00000100 (4).
6. Rotating two positions represents a 90-degree directional rotation: rotateLeft8(0b10000001, 2) = 0b00000110 (6).
7. Compiler derives N-Cell from trace facts: organs SECURITY/MEMORY/ROUTING/COMPOSITION/GOVERNANCE give organMask 0b11111000 (248); authorityMask 0b11111000; header verifies.
8. Observability wrapper preserves canonical execution result: execute {value:4} doubles to 8; stripNCell(wrapped) deep-equals {ok:true, value:8}; wrapped.ncell verifies.
9. Receipt chain detects mutation: two sealed receipts verify; changing the second result breaks the chain.
10. Geometry mapping produces the intended right angle: decodeShape(255) has length 8; isRightAngle((5,3),(4,4),(3,3)) is true.

Appendix C: JSON Schemas

Three schemas are reproduced in full in the source; a fourth template is included. Key requirements:

ncell-header.schema.json

Title: Neuruh N-Cell Header. Required: schema, nodeId, runId, routeMask, organMask, lifecycleMask, authorityMask, memoryMask, outputMask, confidence, risk, topologyHash, observedAt. schema is the constant "neuruh.ncell/1.0". All masks are uint8 (0-255). topologyHash matches ^[a-f0-9]{64}$. codeHashes values match ^[A-Fa-f0-9]{3,64}$. Binary mask strings match ^[01]{8}$. additionalProperties false.

organism-task.schema.json

Title: Neuruh Organism Task. Required: task_id, objective, tenant_id, requested_authority, created_at. requested_authority is an integer 0-255. memory_scopes is a unique string array. human_approval_required is a boolean, default false. additionalProperties false.

run-receipt.schema.json

Title: Neuruh Run Receipt. Required: schema, runId, previousReceiptHash, receiptHash, result. schema is the constant "neuruh.run-receipt/1.0". ncell references the N-Cell header schema. receiptHash matches ^[a-f0-9]{64}$.

platform-gate-register.template.json

Schema "neuruh.platform-gate-register/1.0", with observed_at and a gates array. Each gate records platform, account_owner, dependency_class, status, monthly_cost_usd, credit_or_quota, renewal_or_expiry, systems_affected, failure_behavior, replacement_option, human_action_required, evidence, and notes. The example gate is Supabase, dependency class production-data, status unknown, systems affected APG and LandOS, failure behavior fail-closed, replacement option self-hosted PostgreSQL or managed PostgreSQL. Note: "Verify in provider dashboard before promotion. Never store credentials here."

Appendix D: Local Operations Scripts

ops/check-runtime.sh

Probes nine local endpoints with curl, max 4 seconds each, and prints SERVICE, HTTP, SECONDS, URL: IAR http://127.0.0.1:8090/health; AXON http://127.0.0.1:8788/health; AXON-GW http://127.0.0.1:8300/health; GOVERNANCE http://127.0.0.1:8848/health; OLLAMA http://127.0.0.1:11434/api/tags; ANYTHINGLLM http://127.0.0.1:3001/api/ping; QDRANT http://127.0.0.1:6333/collections; ORGANISM http://127.0.0.1:3010/; APG http://127.0.0.1:3000/login. A failed probe prints 000 / 4.000.

ops/stop-qdrant-backfill.sh

Stops the unauthorized sync_qdrant.py backfill. Logs to the memory incident directory, prints processes before stop and disk state, sends TERM, waits 5 seconds, sends KILL if it survives, then verifies no matching process remains and prints disk state again. A surviving process exits 1 with a warning.

ops/swap-iar.sh

Controlled IAR swap. Verifies the worktree commit equals the expected full SHA 8ab0c59d58627c21b3c1d9ef499018e2c559f1ff and the worktree is clean, captures pre-swap health and process state, stops the old PID listening on 8090 with TERM (aborts if it does not stop within 20 seconds), launches uvicorn iar_v2:app on 127.0.0.1:8090 from the engine directory, waits up to 30 seconds for health, asserts active_backend equals ollama-llama3.2 and that backend is true, then verifies provenance at /admin/verify and records post-swap process state.

ops/bootstrap-neuruh-grok.sh

Neuruh plus Grok Build safe launcher. Default behavior is census plus read-only planning. It does not push, deploy, modify production, use secrets, or edit repos. It checks the Finish Directive exists, installs Grok Build from the official xAI installer if missing, records the Grok version and models, checks the ten required repos (landos-engine, landos-ingest, recipe-engine, territory-engine, neuruh-axon, neuruh-mother, autonomous-governance-core, neuruh-cockpit, world-emitter, neuruh-vault), checks cockpit health, runs grok inspect, then runs a read-only Phase 0 census/plan with the explore agent in plan permission mode and read-only sandbox, streaming JSON to the audit output directory. It ends with instructions to review the output and start the interactive session, approving the plan only after the census proves canonical paths, memory freshness, service boundaries, security constraints, and exact worktrees and acceptance tests.

Appendix E: Neuruh Organism Finish Directive

Included verbatim from the existing Grok/Claude launch pack. It is the evidence-first execution contract for finishing the organism without creating a duplicate architecture.

Mission

Finish the existing Neuruh Modulated Agentic Opportunity Organism by consolidating, wiring, validating, and automating what already exists. Do not create a second organism. Do not rename or replace SAL, PMLA, AXON, MOTHER, AEGIS/IAR, the Galaxy, Worlds, the revenue spine, the knowledge spine, or the existing t0-t6 lane model. The goal is one autonomous, observable, governed system that can: (1) ingest signals and canon, (2) retrieve the correct memory, (3) plan with SAL, (4) govern every action, (5) execute in isolated worktrees, (6) test and validate, (7) write receipts, (8) update memory, (9) surface outcomes, (10) improve without architecture drift.

Hard constraints

• LOCAL BUILD ONLY.
• No push, deploy, production database mutation, production secret use, spending, outbound messaging, or PII processing.
• Never delete source material. Move, archive, or supersede with receipts.
• Repository truth outranks documentation claims.
• Evidence must precede confidence.
• No status may be marked DONE without an executable test and receipt.
• Every code change occurs in a dedicated branch or worktree.
• Every phase produces a machine-readable receipt, a human-readable report, exact tests run, exact files changed, blockers and unresolved contradictions.
• Human approval remains mandatory for external sends, production writes, spend, deploy, push, delete, credential changes, schema promotion.

Canonical estate

Workspace: ~/neuruh-workspace, ~/neuruh-workspace/contracts, ~/neuruh-workspace/audit-output. Repositories: landos-engine, landos-ingest, recipe-engine, territory-engine, neuruh-axon, neuruh-mother, autonomous-governance-core, neuruh-cockpit, world-emitter, neuruh-vault. Expected root: ~/neuruh-repos/NeuruhAI/. Memory roles: Notion is human canon; neuruh-vault is the Git-backed Obsidian-compatible sovereign working-memory filesystem and Galaxy; AnythingLLM AXON-BRAIN is human-facing chat, citation, and workspace RAG derived from the vault; Qdrant is machine-facing vector retrieval for IAR/AXON, additive, not a replacement for AnythingLLM; Dream Service plus PMLA is episodic, behavioral, and consolidated agent memory; Supabase is operational truth and production state, not the document corpus; GitHub is source-code truth; Run Receipts are immutable execution evidence.

Phase 0: Ground-truth census

Do not edit code yet. Produce audit-output/organism-census/ with REPO-CENSUS.md, SERVICE-CENSUS.md, MEMORY-CENSUS.md, CONTRADICTION-LEDGER.md, SECURITY-BOUNDARY.md, CURRENT-ARCHITECTURE.mmd, TARGET-ARCHITECTURE.mmd, repo-state.json, service-state.json, vault-state.json, anythingllm-state.json, acceptance-baseline.json. Audit every repository (path, branch, commit, dirty state, remotes, latest commit date, build and test commands, runtime entrypoint, TODO/FIXME/HACK markers, duplicated or superseded implementation, hardcoded local paths, hardcoded secrets, PII-bearing files, generated artifacts incorrectly tracked). Probe the runtime with real health endpoints, not port-only checks: Bonsai 8100, IAR/AEGIS 8090, AXON 8788, AXON Gateway 8300, AnythingLLM 3001, Ollama 11434, Qdrant 6333, MOTHER, Vault watcher, World Emitter, Cockpit launcher. Inspect the real neuruh-vault root (total files, Markdown count, tracked versus ignored, latest commit, latest modified files, folder taxonomy, duplicates, orphans, unresolved links, PII-local-only lanes, runtime-generated lanes, graph artifacts, receipt chains, codex nodes, Notion mirror freshness, whether Obsidian points at this exact root). Inspect the AnythingLLM AXON-BRAIN workspace (health, identity, document count, last embed time, embedding provider/model, vector backend, duplicate chunks, failed documents, stale documents, inaccessible files, filesystem-agent permissions, citation behavior, API availability, current port). Compare every indexed document against the vault using path plus SHA-256; do not infer freshness from document count. Classify each component only as LIVE, DEGRADED, STALE, BUILT-NOT-WIRED, SPEC-ONLY, SUPERSEDED, BLOCKED, or UNKNOWN. No other vocabulary.

Phase 1: Unified contracts

Create versioned contracts under ~/neuruh-workspace/contracts/: corpus-document.schema.json, memory-source-manifest.schema.json, organism-task.schema.json, governance-decision.schema.json, run-receipt.schema.json, health-state.schema.json, model-route.schema.json, world-manifest.schema.json, outcome-event.schema.json. Minimum corpus-document fields: document_id, source_type (notion, vault, repo, receipt, database), source_uri, vault_path, sha256, modified_at, sensitivity (public, internal, confidential, pii-local-only), tenant_id, node_id, tags, embedding_version, index_targets (anythingllm, qdrant), status (active, superseded, archived, blocked). The same document identity must be used across Vault, AnythingLLM, Qdrant, receipts, and retrieval citations.

Phase 2: Memory freshness pipeline

Build one delta-based memory pipeline: Notion canon, recursive mirror plus SHA manifest, Obsidian/Git vault, delta scanner, corpus manifest, then AnythingLLM embed/update queue and Qdrant upsert/delete-by-version queue. Required behavior: new document indexes; changed SHA replaces the prior embedding version; deleted source is marked superseded, never silently erased; PII-local-only never leaves its approved local boundary; generated runtime lanes are excluded unless explicitly allowlisted; duplicate content has one canonical document with aliases retained; every run produces a receipt with counts and failures; AnythingLLM remains the human chat/citation surface; Qdrant becomes the machine retrieval surface for IAR/AXON; retrieval results include source path, SHA, date, and sensitivity. Acceptance test: create one harmless test note in the vault, run delta sync, confirm it appears in AnythingLLM with a citation and in Qdrant with matching metadata, modify it, confirm both indexes replace the old SHA, archive it, confirm both surfaces mark it superseded without losing the receipt.

Phase 3: One-command organism boot

Extend the existing cockpit; do not replace it. Target command: ~/neuruh-repos/NeuruhAI/neuruh-cockpit/neuruh-up.command. Target health table: BONSAI, IAR, AXON, ANYTHINGLLM, QDRANT, VAULT-WATCHER, MOTHER, COCKPIT. Rules: adopt healthy processes, never double-boot; bind dangerous execution services to loopback by default; fail closed on missing auth; AXON may degrade but must report the exact reason; AnythingLLM remains verify-only unless its documented launcher is safe; every layer exposes a real health probe; boot output prints paths, ports, PIDs, commit SHAs, index freshness, and last receipt; one command boots, verifies, and tails logs; a second run is idempotent; reboot recovery is tested.

Phase 4: Autonomous execution loop

Implement the existing doctrine as one executable state machine: OBSERVE, RETRIEVE, PLAN with SAL, GOVERN with AEGIS/IAR plus Autonomous Governance Core, REQUEST APPROVAL when required, EXECUTE in isolated worktree, TEST, REVIEW with second model/agent, RECEIPT, MEMORY UPDATE through PMLA/Dream, OUTCOME/FEEDBACK, NEXT CYCLE. Each task must carry objective, evidence, permitted repositories, permitted tools, spend ceiling, sensitivity, human-gate requirements, acceptance tests, rollback, receipt destination. The autonomous system may inspect, analyze, create plans, create local branches/worktrees, edit approved local files, run local tests, generate receipts, propose promotion. It may not autonomously push, deploy, send, spend, touch production data, expose secrets, process PII outside its approved local lane, or promote its own policy changes.

Phase 5: Grok Build integration

Treat Grok Build as an execution engine, not the source of truth. Required integration: Grok Build reads AGENTS.md, uses Neuruh skills, uses MCP adapters, runs in plan/read-only by default, writes only in isolated worktrees after approval, emits structured receipts, and is reviewed by a second agent/model. Create ~/neuruh-workspace/AGENTS.md, ~/neuruh-workspace/.grok/, ~/neuruh-workspace/skills/neuruh-organism/, ~/neuruh-workspace/mcp/. The Neuruh Grok skill must teach canonical repo map, t0-t6 lanes, SAL/PMLA/AXON/MOTHER roles, memory source hierarchy, governance boundaries, receipt requirements, no-new-organism rule, status vocabulary, worktree protocol, acceptance gates. Optional but recommended: install the official Grok Build to Claude Code bridge; use Grok for implementation or exploration; use Claude Code for architecture review, critique, and cross-check; reverse roles on the next task; no agent reviews its own work as the sole reviewer.

Phase 6: Final acceptance gates

Memory: Vault path is canonical and Git-backed; Obsidian opens that exact repository root; AnythingLLM index freshness matches the vault manifest; Qdrant index freshness matches the same manifest; same query returns source-consistent evidence from human and machine RAG; PMLA/Dream memory is separate from corpus RAG and has retention rules. Runtime: one-command cold boot; eight layers report honestly; repeated boot is idempotent; reboot recovery succeeds; failure of one optional layer produces DEGRADED, not fake success. Autonomy: a test objective becomes a governed task; a production-write tag triggers escalation; human approval unlocks a local worktree only; implementation runs; tests pass; second-agent review runs; receipt is written; memory is updated; no push/deploy/send/spend occurs. Security: dangerous services bind loopback; no plaintext secrets in tracked files; PII-local-only rules are enforced; policy changes cannot self-promote; kill switch stops new executions; append-only receipts survive failure. Outcome learning: at least one synthetic outcome traverses the full loop; outcome event is attributed to task, recipe, model route, evidence, and world; feedback can alter a shadow score but cannot promote itself without approval.

Required final output

audit-output/final-organism/
  FINAL-STATE.md
  FINAL-ARCHITECTURE.mmd
  FINAL-SERVICE-MAP.json
  FINAL-MEMORY-MANIFEST.json
  FINAL-CONTRADICTION-LEDGER.md
  FINAL-SECURITY-BOUNDARY.md
  FINAL-ACCEPTANCE-RESULTS.json
  FINAL-RUN-RECEIPTS.jsonl
  ROLLBACK.md
  NEXT-OPERATOR-ACTIONS.md

Final response must state what is live, what is autonomous, what still requires human approval, what remains blocked, exact commands to reproduce, exact commits and worktrees, zero unsupported claims. Begin with Phase 0. Stop after the census and plan. Do not edit code until the operator approves the plan.

Appendix F: Acceptance Checklist

Tick each item as it is proven. Nothing here is marked done by this demo; every item requires a live check against the real system.

Explorers and Calculators

All math below re-implements the source definitions in the browser. Nothing here contacts a live service.

Honest gaps