mirror github.com/szl-holdings/amaru@779a0d7e4e69

.devcontainer/devcontainer.json

@@ -0,0 +1,19 @@
+{
+  "name": "SZL Holdings Python Dev",
+  "image": "mcr.microsoft.com/devcontainers/python:3.12",
+  "features": {
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+  "postCreateCommand": "pip install -r requirements.txt 2>/dev/null || pip install -e . 2>/dev/null || true",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "charliermarsh.ruff",
+        "github.copilot"
+      ]
+    }
+  },
+  "remoteUser": "vscode"
+}

.github/CODEOWNERS

@@ -0,0 +1,20 @@
+# SZL Holdings — Code owners
+#
+# These owners will be requested for review when someone opens a pull request.
+# Order matters: the LAST matching pattern wins.
+
+# Default — all files require review by the SZL Holdings core team
+*       @stephenlutar2-hash
+
+# CI / repo configuration
+/.github/                 @stephenlutar2-hash
+/.github/workflows/       @stephenlutar2-hash
+
+# Security-sensitive surface
+SECURITY.md               @stephenlutar2-hash
+LICENSE                   @stephenlutar2-hash
+NOTICE                    @stephenlutar2-hash
+
+# Citation / DOI metadata
+CITATION.cff              @stephenlutar2-hash
+.zenodo.json              @stephenlutar2-hash

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security vulnerability
+    url: https://github.com/szl-holdings/amaru/security/advisories/new
+    about: Report a security vulnerability privately. Do NOT file a public issue for vulnerabilities — see SECURITY.md.
+  - name: Partnership / commercial use
+    url: mailto:partners@szlholdings.com
+    about: Commercial licensing, partnerships, support agreements.
+  - name: Defense Unicorns / UDS catalog inclusion
+    url: mailto:stephen@szlholdings.com
+    about: For Defense Unicorns or other UDS catalog operators interested in republishing Amaru under their own signing key — see docs/FORKING.md first.

.github/ISSUE_TEMPLATE/doctrine_question.yml

@@ -0,0 +1,59 @@
+name: Doctrine question
+description: Challenge a formula, derivation, citation, or invariant. These are first-class — please file them.
+title: "[doctrine] "
+labels: ["doctrine", "needs-triage"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Amaru lives or dies by the correctness of its doctrine. If you think a formula is wrong, a citation is mis-applied, an invariant is unstated, or an assumption is hidden — **please** file this issue. We will respond on the science, not the optics.
+
+  - type: dropdown
+    id: pillar
+    attributes:
+      label: Which doctrinal pillar
+      options:
+        - "Fisher–Rao distance on belief simplex"
+        - "Bohr complementarity floor (σ_A · σ_B ≥ 0.25)"
+        - "Kochen–Specker 18-vector contextuality witness"
+        - "POVM verdict semantics (Σ E_i = I)"
+        - "Tetrad orthonormality"
+        - "Cross-cutting / composition of the above"
+        - "Other (specify below)"
+    validations: { required: true }
+
+  - type: input
+    id: location
+    attributes:
+      label: File or function in question
+      placeholder: "packages/amaru-core/src/quantum/kochen_specker_18.ts :: KS18_CONTEXTS"
+    validations: { required: true }
+
+  - type: textarea
+    id: claim
+    attributes:
+      label: What the code (or doc) currently claims
+      description: Quote the exact line, comment, or derivation step.
+    validations: { required: true }
+
+  - type: textarea
+    id: counter
+    attributes:
+      label: Why you believe it is wrong
+      description: Cite a paper, textbook, derivation, or numeric counter-example. If a numeric counter-example, include the input and the expected vs actual output.
+    validations: { required: true }
+
+  - type: input
+    id: citation
+    attributes:
+      label: Reference (paper / textbook / DOI / arXiv)
+      placeholder: "Cabello, Estebaranz & García-Alcaine, Phys. Lett. A 212, 183 (1996), arXiv:quant-ph/9706009"
+
+  - type: checkboxes
+    id: confirm
+    attributes:
+      options:
+        - label: I have read the relevant section of the cited reference (not just the abstract)
+          required: true
+        - label: I searched existing issues and this is not a duplicate
+          required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,69 @@
+<!--
+Thanks for opening a PR! Please fill in every section below.
+PRs missing the doctrine checklist or DCO sign-off will be blocked.
+-->
+
+## Summary
+
+<!-- 1–3 sentences. What does this change do and why. -->
+
+## Lane
+
+- [ ] **Lane A** (community-open: `artifacts/amaru-uds/`, `docs/`, `.github/`, governance files, smoke tests, examples, bug fixes)
+- [ ] **Lane B** (core proprietary: `packages/amaru-core/` or `packages/amaru-connection/` — confirm the issue is labelled `core:accept-pr`)
+
+## Linked issue
+
+Fixes #<!-- issue number -->
+
+## Type
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Doctrine fix (formula / data / invariant)
+- [ ] Documentation
+- [ ] Build / CI / tooling
+- [ ] Refactor (no behavior change)
+
+## Doctrine pre-flight checklist
+
+<!-- REQUIRED if this PR touches packages/amaru-core/ or packages/amaru-connection/. -->
+<!-- Strike through items that genuinely do not apply and say why. -->
+
+- [ ] POVM completeness: `Σ E_i = I` within 1e-9 for all constructed POVMs
+- [ ] KS-18 2-regular cover preserved: every vector index appears in exactly 2 of 9 contexts
+- [ ] KS-18 unsatisfiability: exhaustive `{0,1}^18` search returns 0 satisfying assignments
+- [ ] Tetrad orthonormality: `⟨e_i, e_j⟩ = δ_ij` within 1e-9
+- [ ] Bohr complementarity floor: `σ_A · σ_B ≥ 0.25 − ε` on the worst-case conjugate pair
+- [ ] Fisher–Rao metric: zero, symmetry, triangle inequality, simplex closed form
+- [ ] `node doctrine-demo.mjs` against the rebuilt dist shows the expected verdict table
+
+If you skipped any item, explain why here:
+<!-- ... -->
+
+## Tests
+
+- [ ] New behavior has a unit test
+- [ ] Bug fix has a regression test that failed on `main` and passes with this PR
+- [ ] `pnpm -F @amaru/core test:doctrine` is green locally
+- [ ] `bash scripts/smoke-from-public-url.sh` is green locally (for release-affecting PRs)
+
+## Documentation
+
+- [ ] `CHANGELOG.md` updated under `## [Unreleased]`
+- [ ] Public docs (`docs/`, `README.md`) updated where behavior changed
+- [ ] Code comments updated where a non-obvious invariant changed
+
+## Backward compatibility
+
+- [ ] No public API change
+- [ ] Public API change — migration note added to `CHANGELOG.md`
+- [ ] UDS package layout change — `MANIFEST.json` and `OPERATOR-QUICKSTART.md` updated
+
+## DCO sign-off
+
+- [ ] Every commit in this PR has a `Signed-off-by:` trailer (use `git commit -s`)
+
+## Reviewer notes
+
+<!-- Anything reviewers should look at first, edge cases, deliberate non-goals, etc. -->

.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"
+      - "github-actions"
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10
+    labels:
+      - "dependencies"
+      - "javascript"

.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: Docs CI
+
+# CI for showcase repos that ship documentation and metadata only.
+# Validates citation files, markdown, links, governance files, and runs
+# the secret scan. Path filters prevent unnecessary runs on asset-only
+# changes (e.g. social previews) so we don't churn cancelled runs.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - '**.md'
+      - '**.cff'
+      - 'LICENSE'
+      - 'NOTICE'
+      - '.github/**'
+  pull_request:
+    branches: [main]
+    paths:
+      - '**.md'
+      - '**.cff'
+      - 'LICENSE'
+      - 'NOTICE'
+      - '.github/**'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  docs:
+    uses: szl-holdings/.github/.github/workflows/reusable-docs-ci.yml@c8359e53b40560f15ed5c25c3e4e1256b0536cf8 # v1 (.github main)
+
+  secrets:
+    uses: szl-holdings/.github/.github/workflows/reusable-secret-scan.yml@c8359e53b40560f15ed5c25c3e4e1256b0536cf8 # v1 (.github main)

.github/workflows/codeql.yml

@@ -0,0 +1,51 @@
+name: CodeQL
+
+# Series-A security gate — Doctrine v6
+# Scans JavaScript/TypeScript source and GitHub Actions workflows.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: '23 4 * * 1'  # Mondays 04:23 UTC
+
+permissions:
+  contents: read
+
+concurrency:
+  group: codeql-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [javascript-typescript, actions]
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@9af89fc71515a100421586dfdb3dc9c984fbf411 # v2.19.4
+        with:
+          egress-policy: audit
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v4
+        with:
+          persist-credentials: false
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        with:
+          languages: ${{ matrix.language }}
+          queries: security-extended,security-and-quality
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        with:
+          category: '/language:${{ matrix.language }}'

.github/workflows/dco.yml

@@ -0,0 +1,11 @@
+name: DCO
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+permissions:
+  contents: read
+  pull-requests: read
+jobs:
+  dco:
+    uses: szl-holdings/.github/.github/workflows/reusable-dco.yml@main
+    secrets: inherit

.github/workflows/sbom.yml

@@ -0,0 +1,24 @@
+name: SBOM (CycloneDX + SPDX + Trivy)
+
+# Calls the org-level reusable SBOM pipeline.
+# Pinned to .github commit f0961db0f44d8e53f956ccab14bdfa4a22e4e49b (2026-05-28).
+# Series-A supply-chain compliance: CIS SSCS 2.4.4 / NTIA minimum elements.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+
+jobs:
+  sbom:
+    name: SBOM
+    uses: szl-holdings/.github/.github/workflows/reusable-sbom.yml@f0961db0f44d8e53f956ccab14bdfa4a22e4e49b
+    with:
+      attach-to-release: true
+    permissions:
+      contents: write
+      security-events: write
+

.github/workflows/scorecard.yml

@@ -0,0 +1,43 @@
+name: Scorecard supply-chain security
+on:
+  branch_protection_rule:
+  schedule:
+    - cron: '32 7 * * 2'
+  push:
+    branches: [ "main" ]
+
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      id-token: write
+      contents: read
+      actions: read
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        with:
+          sarif_file: results.sarif

.github/workflows/slsa.yml

@@ -0,0 +1,90 @@
+name: SLSA Level 3 Provenance
+
+# Generates SLSA Level 3 provenance attestation for release artifacts.
+# The attestation (.intoto.jsonl) is uploaded alongside release assets,
+# providing cryptographically verifiable build provenance for Series-A
+# supply-chain diligence and downstream consumer verification.
+#
+# SLSA generator pinned to slsa-framework/slsa-github-generator v2.1.0
+# commit SHA: f7dd8c54c2067bafc12ca7a55595d5ee9b75204a (2025-02-24)
+#
+# IMPORTANT: This workflow changes release behavior — it generates a
+# provenance attestation for every published release. Founder review
+# required before merge.
+#
+# Verification: consumers can verify with:
+#   slsa-verifier verify-artifact <artifact> \
+#     --provenance-path <artifact>.intoto.jsonl \
+#     --source-uri github.com/szl-holdings/amaru
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write    # Required for SLSA provenance signing
+  contents: write    # Required to upload attestation to release
+  actions: read      # Required by SLSA generator to read workflow
+
+jobs:
+  # ---------------------------------------------------------------------------
+  # 1. Build the release artifact and compute its hash.
+  # ---------------------------------------------------------------------------
+  build:
+    name: Build release artifact
+    runs-on: ubuntu-latest
+    outputs:
+      artifact-name: ${{ steps.set-output.outputs.artifact-name }}
+      artifact-sha256: ${{ steps.hash.outputs.sha256 }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Create release archive
+        id: set-output
+        run: |
+          set -euo pipefail
+          ARTIFACT="amaru-${{ github.event.release.tag_name }}.tar.gz"
+          # Package the repo source (adjust for language-specific build output)
+          git archive --format=tar.gz \
+            --prefix="amaru-${{ github.event.release.tag_name }}/" \
+            HEAD \
+            -o "$ARTIFACT"
+          echo "artifact-name=$ARTIFACT" >> "$GITHUB_OUTPUT"
+
+      - name: Compute SHA-256
+        id: hash
+        run: |
+          set -euo pipefail
+          ARTIFACT="${{ steps.set-output.outputs.artifact-name }}"
+          SHA=$(sha256sum "$ARTIFACT" | awk '{print $1}')
+          echo "sha256=$SHA" >> "$GITHUB_OUTPUT"
+          echo "Artifact: $ARTIFACT"
+          echo "SHA256:   $SHA"
+
+      - name: Upload artifact for provenance job
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: release-artifact
+          path: ${{ steps.set-output.outputs.artifact-name }}
+          retention-days: 1
+          if-no-files-found: error
+
+  # ---------------------------------------------------------------------------
+  # 2. Generate SLSA Level 3 provenance attestation.
+  #    This is a reusable workflow call — it runs in a separate job with
+  #    hermetic build environment verification.
+  # ---------------------------------------------------------------------------
+  provenance:
+    name: Generate SLSA provenance
+    needs: [build]
+    permissions:
+      id-token: write
+      contents: write
+      actions: read
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@f7dd8c54c2067bafc12ca7a55595d5ee9b75204a
+    with:
+      base64-subjects: ${{ needs.build.outputs.artifact-sha256 }}
+      upload-assets: true
+      provenance-name: amaru-${{ github.event.release.tag_name }}.intoto.jsonl
+

.hf/README.md

@@ -0,0 +1,47 @@
+---
+license: other
+tags:
+  - proof-chain
+  - ai-governance
+  - blockchain
+  - cardano
+  - attestation
+  - anchoring
+  - series-a
+  - szl-holdings
+language:
+  - en
+pretty_name: "SZLHOLDINGS/amaru-source"
+---
+
+# SZLHOLDINGS/amaru-source
+
+Cardano-anchored governance receipt minting + Shor-encoded provenance.
+
+License: Proprietary (see LICENSE file in repo)
+
+## Mirror of
+
+GitHub source: [szl-holdings/amaru](https://github.com/szl-holdings/amaru)
+
+## Verification Receipt
+
+| Field | Value |
+|-------|-------|
+| Source GitHub URL | https://github.com/szl-holdings/amaru |
+| Commit SHA | `779a0d7e4e695d52a56f8f698383bba12c7a43a2` |
+| Retrieval Timestamp | 2026-05-28T22:49:00Z |
+| Mirror Agent | HF GH-MIRROR (Doctrine v6) |
+| License | other |
+
+## Cross-links
+
+- Org: [huggingface.co/SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS)
+- Platform monorepo mirror: [SZLHOLDINGS/platform-source](https://huggingface.co/datasets/SZLHOLDINGS/platform-source)
+- Thesis mirror: [SZLHOLDINGS/ouroboros-thesis-source](https://huggingface.co/datasets/SZLHOLDINGS/ouroboros-thesis-source)
+- Formal proofs: [SZLHOLDINGS/thesis-v18-formal-verification](https://huggingface.co/datasets/SZLHOLDINGS/thesis-v18-formal-verification)
+- UDS receipts: [SZLHOLDINGS/uds-spans-receipts](https://huggingface.co/datasets/SZLHOLDINGS/uds-spans-receipts)
+
+## License
+
+This mirror is distributed under [other](https://github.com/szl-holdings/amaru/blob/main/LICENSE). See LICENSE file in the root of this dataset.

.zenodo.json

@@ -0,0 +1,38 @@
+{
+  "title": "amaru \u2014 Convergent multi-source data sync. Append-only delta logs, hash-verified ingest, and bounded loops with measurable convergence.",
+  "description": "Convergent multi-source data sync. Append-only delta logs, hash-verified ingest, and bounded loops with measurable convergence.",
+  "upload_type": "software",
+  "creators": [
+    {
+      "name": "Lutar, Stephen P.",
+      "affiliation": "SZL Holdings",
+      "orcid": "0009-0001-0110-4173"
+    }
+  ],
+  "access_right": "open",
+  "license": "Apache-2.0",
+  "keywords": [
+    "proof-chain",
+    "ai-governance",
+    "amaru",
+    "append-only-log",
+    "series-a",
+    "convergent-sync",
+    "data-convergence",
+    "governed-ingest",
+    "szl-holdings",
+    "ouroboros"
+  ],
+  "communities": [
+    {
+      "identifier": "open-science"
+    }
+  ],
+  "related_identifiers": [
+    {
+      "identifier": "10.5281/zenodo.19944926",
+      "relation": "isSupplementTo",
+      "scheme": "doi"
+    }
+  ]
+}

CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Series-A presentation pass: SECURITY.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md, CODEOWNERS
+- Apache-2.0 LICENSE
+- CITATION.cff for independent citation
+
+## Release index
+
+Releases are tagged on this repository. See [GitHub Releases](../../releases) for the full list.

CITATION.cff

@@ -0,0 +1,49 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite the SZL Holdings research thesis (Ouroboros Thesis v13) and reference this component."
+title: "amaru — Convergent multi-source data sync. Append-only delta logs, hash-verified ingest, and bounded loops with measurable convergence."
+version: "0.2.0"
+date-released: "2026-05-29"
+abstract: >-
+  Convergent multi-source data sync. Append-only delta logs, hash-verified ingest, and bounded loops with measurable convergence. Component of the SZL Holdings governed AI decision infrastructure,
+  built on the Ouroboros Thesis (DOI 10.5281/zenodo.19944926).
+type: software
+authors:
+  - family-names: Lutar
+    given-names: "Stephen P."
+    name-suffix: "Jr."
+
+    email: stephen@szlholdings.com
+    affiliation: SZL Holdings
+    orcid: "https://orcid.org/0009-0001-0110-4173"
+license: LicenseRef-SZL-Proprietary
+url: "https://github.com/szl-holdings/amaru"
+repository-code: "https://github.com/szl-holdings/amaru"
+keywords:
+  - szl-holdings
+  - ai-governance
+  - decision-intelligence
+  - ouroboros-thesis
+identifiers:
+  - description: "Ouroboros Thesis v13 — research foundation (Zenodo)"
+    type: doi
+    value: "10.5281/zenodo.20173912"
+  - description: "Ouroboros Thesis concept DOI — always-latest"
+    type: doi
+    value: "10.5281/zenodo.19944926"
+  - description: "ORCID iD of the principal author"
+    type: other
+    value: "https://orcid.org/0009-0001-0110-4173"
+preferred-citation:
+  type: software
+  title: "amaru — Convergent multi-source data sync. Append-only delta logs, hash-verified ingest, and bounded loops with measurable convergence."
+  authors:
+    - family-names: Lutar
+      given-names: "Stephen P."
+      name-suffix: "Jr."
+
+      email: stephen@szlholdings.com
+      affiliation: SZL Holdings
+      orcid: "https://orcid.org/0009-0001-0110-4173"
+  year: 2026
+  url: "https://github.com/szl-holdings/amaru"
+doi: 10.5281/zenodo.20434276

CODE_OF_CONDUCT.md

@@ -0,0 +1,53 @@
+# Code of Conduct
+
+  ## Our pledge
+
+  We — maintainers, contributors, and community members of the [SZL Holdings](https://github.com/szl-holdings) repositories — pledge to make participation in our projects a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+  We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+  ## Our standards
+
+  Examples of behavior that contributes to a positive environment:
+
+  - Demonstrating empathy and kindness toward other people
+  - Being respectful of differing opinions, viewpoints, and experiences
+  - Giving and gracefully accepting constructive feedback
+  - Accepting responsibility, apologizing to those affected by mistakes, and learning from the experience
+  - Focusing on what is best not just for ourselves but for the overall community
+
+  Examples of unacceptable behavior:
+
+  - Sexualized language or imagery, and sexual attention or advances of any kind
+  - Trolling, insulting or derogatory comments, and personal or political attacks
+  - Public or private harassment
+  - Publishing others' private information, such as a physical or email address, without their explicit permission
+  - Other conduct which could reasonably be considered inappropriate in a professional setting
+
+  ## Enforcement responsibilities
+
+  Repository maintainers are responsible for clarifying and enforcing standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior deemed inappropriate, threatening, offensive, or harmful.
+
+  ## Scope
+
+  This Code of Conduct applies within all community spaces — issues, pull requests, discussions, code reviews, public communications channels — and also applies when an individual is officially representing the community in public spaces.
+
+  ## Enforcement
+
+  Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the maintainers at [conduct@szlholdings.com](mailto:conduct@szlholdings.com). All complaints will be reviewed and investigated promptly and fairly.
+
+  All maintainers are obligated to respect the privacy and security of the reporter of any incident.
+
+  ## Enforcement guidelines
+
+  Maintainers will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+  1. **Correction** — A private, written warning, providing clarity around the nature of the violation.
+  2. **Warning** — A warning with consequences for continued behavior. Continuing leads to a temporary ban.
+  3. **Temporary Ban** — A temporary ban from any sort of interaction or public communication with the community.
+  4. **Permanent Ban** — A permanent ban from any sort of public interaction within the community.
+
+  ## Attribution
+
+  This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/), version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).
+  

CONTRIBUTING.md

@@ -0,0 +1,124 @@
+# Contributing to Amaru
+
+Thanks for your interest. This repository is part of the [SZL Holdings](https://github.com/szl-holdings) platform — physics-grounded, governed AI decision infrastructure for regulated environments. Amaru is published source-available so it can be audited, evaluated, deployed into air-gapped environments (UDS / Zarf), and forked by partners.
+
+This document is the **single source of truth** for how to contribute. Two lanes exist; pick the one that matches your change.
+
+---
+
+## Two contribution lanes
+
+### Lane A — Community-open surface (PRs welcome, no prior agreement)
+
+PRs are accepted for the following directories without a partnership agreement, under the DCO terms below:
+
+| Surface | What lives there |
+|---|---|
+| `artifacts/amaru-uds/` | The UDS/Zarf payload, build scripts, deploy manifests, doctrine demo |
+| `docs/` | Public-facing documentation (architecture, security, UDS-bundle, forking, runbooks) |
+| `.github/`, `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `SECURITY.md`, `GOVERNANCE.md`, `ROADMAP.md` | Repo governance files |
+| Smoke tests against the **public release URL** | `scripts/smoke-*` and equivalent |
+| `examples/`, `samples/`, `tutorials/` | New worked examples that exercise the shipped doctrine |
+| Bug fixes to anything above | Including correctness fixes to formulas / data tables |
+
+If a downstream consumer (e.g. Defense Unicorns) forks Amaru into their own org to re-sign and republish as their own UDS package, the entire `artifacts/amaru-uds/` tree, this `CONTRIBUTING.md`, and the doctrine demo are intentionally structured to make that fork productive on day one. See [`docs/FORKING.md`](./docs/FORKING.md).
+
+### Lane B — Core proprietary surface (coordinated only)
+
+`packages/amaru-core/` and `packages/amaru-connection/` contain the proprietary doctrine implementation. Drive-by PRs touching these files will be closed with a pointer to this section. To contribute here:
+
+1. Open an issue describing what you want to change and **why** (cite the relevant physics or the failing observation).
+2. Wait for a maintainer to label it `core:accept-pr`. We will tell you within 7 days if a PR is wanted.
+3. Then open the PR.
+
+This is not about gatekeeping — it's because changes here can silently violate doctrine invariants (POVM completeness, KS-18 2-cover, Bohr floor) in ways that a smoke test catches but a code review easily misses. We want to be in the loop **before** you spend the time.
+
+---
+
+## Doctrine pre-flight checklist (REQUIRED for any PR touching `packages/amaru-core/`)
+
+Every PR that touches the doctrine code MUST keep these invariants green. CI runs them; if they fail, the PR will not merge.
+
+1. **POVM completeness.** For every constructed POVM, `Σ E_i = I` to within `1e-9`.
+2. **KS-18 2-regular cover.** Each of the 18 vector indices appears in **exactly 2** of the 9 contexts. Verified by `Σ_ctx Σ_v 1[v∈ctx] = 36` and `∀v: count(v) == 2`.
+3. **KS-18 unsatisfiability.** Exhaustive `{0,1}^18` search returns 0 assignments where every context sums to 1.
+4. **Tetrad orthonormality.** Frame vectors satisfy `⟨e_i, e_j⟩ = δ_ij` to within `1e-9`.
+5. **Bohr complementarity floor.** For any conjugate pair (A,B) at maximum admissible noise, `σ_A · σ_B ≥ 0.25 − ε`.
+6. **Fisher–Rao metric.** `d(p,p) = 0`, `d(p,q) = d(q,p)`, triangle inequality on random simplex samples, and reduces to `2·arccos(Σ√(p_i q_i))` on the simplex.
+
+**Why these and not "the tests pass":** unit tests can drift; these six properties are the contract. If you break one, Amaru stops being Amaru regardless of what the rest of the suite says.
+
+Run them locally before opening the PR:
+
+```bash
+pnpm -F @amaru/core test:doctrine
+node dist/amaru-uds/doctrine-demo.mjs <core-dir> <conn-dir>
+bash scripts/smoke-from-public-url.sh
+```
+
+---
+
+## DCO sign-off (REQUIRED on every commit)
+
+Every commit must be signed off under the [Developer Certificate of Origin 1.1](https://developercertificate.org/). The DCO is a lightweight per-commit attestation that you wrote the code or have the right to contribute it. Use `git commit -s` to add the trailer automatically:
+
+```
+Signed-off-by: Real Name <real-email@example.com>
+```
+
+PRs without a DCO sign-off on every commit will be blocked by CI. We use DCO instead of a CLA so individuals can contribute without paperwork.
+
+By signing off you also grant the project the license terms in [`LICENSE`](./LICENSE) for the contributed change.
+
+---
+
+## How to open a good PR
+
+1. **Open the issue first** if the change is non-trivial (more than ~30 lines or any user-visible behavior change). Drive-by refactors will be asked to start with an issue.
+2. **One logical change per PR.** No "and while I was in there..." commits.
+3. **Tests.** New behavior gets a test. Bug fixes get a regression test that fails on `main` and passes with the PR.
+4. **Doctrine demo.** If you touched anything in `packages/amaru-core/` or `packages/amaru-connection/`, run `node doctrine-demo.mjs` against the rebuilt dist and paste the output in the PR body.
+5. **Conventional commit subject line.** `feat:`, `fix:`, `docs:`, `chore:`, `refactor:`, `test:`, `ci:`, `perf:`, `build:`. Keep the subject ≤ 72 chars.
+6. **Update `CHANGELOG.md`** under `## [Unreleased]` if your change is user-visible.
+
+The PR template will walk you through this.
+
+---
+
+## Issues
+
+Use the issue templates — they exist so you don't have to guess what we need:
+
+- **Bug report** — something that worked is now broken, or something doesn't match the docs / paper citation.
+- **Feature request** — something new you'd like to be able to do.
+- **Doctrine question** — you think a formula, derivation, or invariant is wrong. These are first-class — please file them.
+- **Security disclosure** — see [`SECURITY.md`](./SECURITY.md). **Do not open a public issue for vulnerabilities.**
+
+---
+
+## Code of Conduct
+
+By participating you agree to the [Code of Conduct](./CODE_OF_CONDUCT.md). We follow Contributor Covenant 2.1. The project lead is the enforcement contact: `stephen@szlholdings.com`.
+
+---
+
+## Governance and decision-making
+
+See [`GOVERNANCE.md`](./GOVERNANCE.md) for who decides what, the review SLA, and how the maintainer roster changes.
+
+For a snapshot of where the project is going next, see [`ROADMAP.md`](./ROADMAP.md).
+
+---
+
+## Quick links
+
+| If you want to... | Go to |
+|---|---|
+| Report a bug | [New issue → Bug report](../../issues/new?template=bug_report.yml) |
+| Suggest a feature | [New issue → Feature request](../../issues/new?template=feature_request.yml) |
+| Challenge a formula or derivation | [New issue → Doctrine question](../../issues/new?template=doctrine_question.yml) |
+| Disclose a vulnerability | [`SECURITY.md`](./SECURITY.md) |
+| Fork Amaru into your own UDS catalog | [`docs/FORKING.md`](./docs/FORKING.md) |
+| Verify a published release | [`OPERATOR-QUICKSTART.md`](https://github.com/szl-holdings/amaru/releases/latest) |
+
+— Amaru maintainers

GOVERNANCE.md

@@ -0,0 +1,53 @@
+# Governance
+
+Amaru is sponsored and maintained by **SZL Holdings, LLC**. This document describes who decides what, the response SLA you can expect, and how the maintainer roster changes.
+
+## Roles
+
+| Role | Who | What they can do |
+|---|---|---|
+| **Project Lead** | Stephen Z. Lopez (`@szl`) | Final say on doctrine, license, releases, signing keys, roadmap |
+| **Maintainer** | Listed in [`.github/CODEOWNERS`](./.github/CODEOWNERS) | Triage, review, merge in Lane A; approve `core:accept-pr` labels |
+| **Contributor** | Anyone with a merged commit | Open issues, open PRs in Lane A, request reviews |
+| **Downstream operator** | E.g. Defense Unicorns republishing Amaru under their own signing key | Owns their fork end-to-end; upstream issues welcome; see [`docs/FORKING.md`](./docs/FORKING.md) |
+
+## Decision SLAs (best effort, calendar days)
+
+| Action | Response SLA |
+|---|---|
+| Acknowledge a new issue (triage label + comment) | 3 days |
+| Decide whether a core PR is wanted (`core:accept-pr`) | 7 days |
+| First review on a Lane A PR | 5 days |
+| Security advisory acknowledgement | 2 days |
+| Doctrine question response (first substantive reply) | 7 days |
+
+We do not run a "stale bot." If an issue has stalled past these SLAs, please comment on the issue or email `stephen@szlholdings.com`.
+
+## How decisions are made
+
+- **Lazy consensus.** Any maintainer may approve and merge a Lane A PR that passes CI and is uncontested for 48 hours after review.
+- **Doctrine changes** (anything touching `packages/amaru-core/`) require Project Lead sign-off in addition to a maintainer review. The doctrine pre-flight checklist in [`CONTRIBUTING.md`](./CONTRIBUTING.md) must be green.
+- **Release cuts** (new `uds-vX.Y.Z` tag) are signed by the Project Lead's cosign key. Downstream operators re-sign with their own key — see [`docs/FORKING.md`](./docs/FORKING.md).
+- **License changes** are exclusively a Project Lead decision and require notice on the issue tracker 30 days in advance.
+
+## Becoming a maintainer
+
+You become a maintainer by doing the work, not by asking. The path:
+
+1. Land 3+ non-trivial Lane A PRs reviewed by an existing maintainer.
+2. Triage at least 10 issues (label, ask the right clarifying questions, close obvious dupes).
+3. Show up on at least one doctrine question with a substantive, cited response.
+4. An existing maintainer nominates you on a tracking issue. Project Lead confirms.
+
+Maintainer status can be relinquished at any time and is reviewed annually for activity.
+
+## Forks and downstream catalogs
+
+If your organization (e.g. a UDS catalog operator) forks Amaru and republishes it under your own signing key:
+
+- You own your fork's release cadence, signing key, and support model.
+- You may open upstream issues; we will engage on doctrine and on bugs reproducible against the upstream release.
+- You are not obligated to upstream changes. If you choose to, the standard contribution lanes apply.
+- Trademark "Amaru" remains with SZL Holdings, LLC. Your fork should use a distinct name for distribution (e.g. "Org-Amaru" or "Amaru-Org").
+
+See [`docs/FORKING.md`](./docs/FORKING.md) for the operational playbook.

LICENSE

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: LicenseRef-SZL-Proprietary
+
+PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 SZL Holdings, LLC. All rights reserved.
+
+1. Definitions
+
+   "Software" means the source code, object code, documentation, configuration,
+   data, models, prompts, schemas, and all other materials contained in this
+   repository, in any form.
+
+   "Licensor" means SZL Holdings, LLC.
+
+   "You" means the individual or legal entity accessing the Software.
+
+2. Grant
+
+   No license, express or implied, is granted to You under this LICENSE except
+   the limited right to view the Software in this repository solely for
+   evaluation and reference. All other rights are expressly reserved by
+   Licensor.
+
+3. Restrictions
+
+   Without Licensor's prior written consent, You may not, in whole or in part:
+
+   (a) copy, fork, mirror, redistribute, sublicense, sell, rent, or lease the
+       Software;
+   (b) create derivative works of, modify, translate, or adapt the Software;
+   (c) use the Software in production, in any commercial product or service,
+       or to train, fine-tune, or evaluate any machine-learning model;
+   (d) remove or obscure any proprietary, copyright, trademark, or attribution
+       notices;
+   (e) reverse engineer, decompile, or disassemble the Software, except to the
+       extent such restriction is prohibited by applicable law.
+
+4. Trademarks
+
+   "SZL Holdings", "Ouroboros", "A11oy", "Sentra", "Amaru", "Counsel",
+   "Terra", "Vessels", "Carlota Jo", "Conduit", and associated logos are
+   trademarks of SZL Holdings, LLC. No trademark rights are granted under
+   this LICENSE.
+
+5. Confidentiality
+
+   The Software contains confidential and proprietary information of
+   Licensor. You agree to maintain its confidentiality with at least the
+   same degree of care You use to protect Your own confidential information,
+   and in no event less than reasonable care.
+
+6. Disclaimer of Warranty
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE", WITHOUT WARRANTY OF
+   ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+   NON-INFRINGEMENT.
+
+7. Limitation of Liability
+
+   IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THIS LICENSE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGES.
+
+8. Termination
+
+   This LICENSE terminates automatically upon any breach. Upon termination,
+   You must destroy all copies of the Software in Your possession.
+
+9. Governing Law
+
+   This LICENSE is governed by the laws of the State of New York, USA,
+   without regard to its conflict-of-law provisions. Exclusive jurisdiction
+   and venue lie in the state and federal courts located in New York County,
+   New York.
+
+10. Contact
+
+    For licensing inquiries, partnerships, or evaluation requests:
+    licensing@szlholdings.com  ·  https://szlholdings.com

NOTICE

@@ -0,0 +1,14 @@
+NOTICE
+
+This product includes software developed by SZL Holdings, LLC.
+
+"SZL Holdings", "Ouroboros", "A11oy", "Sentra", "Amaru", "Counsel", "Terra",
+"Vessels", "Carlota Jo", and "Conduit" are trademarks of SZL Holdings, LLC.
+All other trademarks are the property of their respective owners.
+
+Use of these names, logos, or marks is subject to the trademark policy
+described in the LICENSE file. Nothing in this repository grants any
+trademark license.
+
+For permissions, partnerships, or licensing inquiries:
+stephen@szlholdings.com

README.md

@@ -0,0 +1,77 @@
+---
+license: other
+tags:
+  - proof-chain
+  - ai-governance
+  - blockchain
+  - cardano
+  - attestation
+  - anchoring
+  - series-a
+  - shor-code
+  - szl-holdings
+language:
+  - en
+pretty_name: "SZLHOLDINGS/amaru-source"
+---
+
+# SZLHOLDINGS/amaru-source
+
+[![GitHub](https://img.shields.io/badge/GitHub-szl--holdings%2Famaru-181717?logo=github)](https://github.com/szl-holdings/amaru)
+[![License](https://img.shields.io/badge/license-Proprietary-blue)](https://github.com/szl-holdings/amaru/blob/main/LICENSE)
+[![Doctrine](https://img.shields.io/badge/doctrine-v6-blueviolet)](https://huggingface.co/SZLHOLDINGS)
+[![Series A](https://img.shields.io/badge/stage-Series%20A-orange)](https://huggingface.co/SZLHOLDINGS)
+[![Mirror](https://img.shields.io/badge/mirror-GH%20→%20HF-green)](https://huggingface.co/datasets/SZLHOLDINGS/amaru-source)
+
+**Amaru** — Cardano-anchored governance receipt minting + Shor-encoded provenance. Blockchain anchoring layer for SZL's immutable audit trail.
+
+
+
+---
+
+## 🔍 Verification Receipt
+
+| Field | Value |
+|-------|-------|
+| **Source** | [github.com/szl-holdings/amaru](https://github.com/szl-holdings/amaru) |
+| **Commit SHA** | `779a0d7e4e695d52a56f8f698383bba12c7a43a2` |
+| **Snapshot URL** | https://github.com/szl-holdings/amaru/tree/779a0d7e4e695d52a56f8f698383bba12c7a43a2 |
+| **Retrieved** | 2026-05-28T22:54:00Z |
+| **Mirror Agent** | HF GH-MIRROR · Doctrine v6 |
+| **License** | Proprietary |
+| **HF Dataset** | [SZLHOLDINGS/amaru-source](https://huggingface.co/datasets/SZLHOLDINGS/amaru-source) |
+
+---
+
+## 🏗️ Contents
+
+This dataset contains the full source tree of [szl-holdings/amaru](https://github.com/szl-holdings/amaru) at the commit SHA above, excluding:
+- `.git/` version-control internals
+- `node_modules/` vendored dependencies
+- Binary video/archive artifacts >50 MB (if any)
+
+---
+
+## 🔗 SZLHOLDINGS Ecosystem
+
+| Artifact | Type | Link |
+|----------|------|------|
+| Org Card | Model | [SZLHOLDINGS/SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS) |
+| Platform monorepo | Dataset | [SZLHOLDINGS/platform-source](https://huggingface.co/datasets/SZLHOLDINGS/platform-source) |
+| Ouroboros Thesis | Dataset | [SZLHOLDINGS/ouroboros-thesis-source](https://huggingface.co/datasets/SZLHOLDINGS/ouroboros-thesis-source) |
+| Formal Proofs (Lean 4) | Dataset | [SZLHOLDINGS/thesis-v18-formal-verification](https://huggingface.co/datasets/SZLHOLDINGS/thesis-v18-formal-verification) |
+| UDS Spans + Receipts | Dataset | [SZLHOLDINGS/uds-spans-receipts](https://huggingface.co/datasets/SZLHOLDINGS/uds-spans-receipts) |
+| a11oy v19 Substrate | Model | [SZLHOLDINGS/a11oy-v19-substrate](https://huggingface.co/SZLHOLDINGS/a11oy-v19-substrate) |
+| Showcase Space | Space | [SZLHOLDINGS/szl-showcase](https://huggingface.co/spaces/SZLHOLDINGS/szl-showcase) |
+| Lutar Lean Browser | Space | [SZLHOLDINGS/lutar-lean-browser](https://huggingface.co/spaces/SZLHOLDINGS/lutar-lean-browser) |
+| MCP Receipts Server | Space | [SZLHOLDINGS/mcp-receipts-server](https://huggingface.co/spaces/SZLHOLDINGS/mcp-receipts-server) |
+
+---
+
+## ⚖️ License
+
+Distributed under **Proprietary**. See the [LICENSE](https://github.com/szl-holdings/amaru/blob/main/LICENSE) file in the source repository.
+
+---
+
+*Mirror generated by HF GH-MIRROR agent · Doctrine v6 · 2026-05-28T22:54:00Z*

ROADMAP.md

@@ -0,0 +1,39 @@
+# Roadmap
+
+A snapshot of where Amaru is heading. Issues are the source of truth — this is a navigational summary, not a contract.
+
+## Now — `uds-v0.1.x` line (shipped, hardening)
+
+- ✅ Signed UDS/Zarf payload with offline cosign verify
+- ✅ Doctrine demo (`doctrine-demo.mjs`) — 30 s post-deploy live verdict harness
+- ✅ Public-URL smoke test (17/17 from a clean tmpdir)
+- ✅ KS-18 witness with verified 2-regular cover and exhaustive unsatisfiability
+- 🔄 Per-file MANIFEST.json with sha256 of every payload file (in v0.1.1; documenting)
+- 🔄 SBOM hardening: pin every transitive dep version in the SBOM, not just direct
+
+## Next — `uds-v0.2.0` (target: Warhacker week + 30 days)
+
+- [ ] **Keyless / Fulcio signing path.** Currently we ship a dev cosign keypair. Add an optional keyless cosign signing flow against the public Sigstore Fulcio so downstream verifiers can use OIDC identity-based verification.
+- [ ] **UDS bundle reference deployment.** A complete, tested `uds-bundle.yaml` that boots Amaru plus a sample policy gate in a minimal UDS cluster.
+- [ ] **Doctrine demo expansion.** Add a 2-cover violation regression case so the demo itself would have caught the v0.1.0 KS-18 bug if it had been shipped.
+- [ ] **POVM verdict streaming API.** A documented streaming interface so downstream pipelines can feed live observations into the verdict head without a request/response boundary.
+- [ ] **CONTRIBUTING / GOVERNANCE hardening.** Codify the doctrine pre-flight as a required GitHub Action that blocks merge.
+
+## Later — `uds-v0.3.0+`
+
+- [ ] **Multi-party doctrine composition.** When two Amaru instances need to compose verdicts (e.g. coalition deployments), spell out and enforce the composition rules.
+- [ ] **Hardware attestation hooks.** TPM / SEV-SNP attestation of the running Amaru binary tied back to the cosign signature.
+- [ ] **Reference UDS catalog entry.** A pull request to [`defenseunicorns/uds-package`](https://github.com/defenseunicorns/uds-package) (only after discussion with Defense Unicorns).
+- [ ] **Formal verification stub.** A small Lean / Coq / TLA+ formalization of the POVM completeness invariant.
+
+## Out of scope (deliberately)
+
+- Amaru is **not** a model. It does not train, fine-tune, or host LLMs. It is a verdict layer on top of model outputs.
+- Amaru is **not** an MLOps platform. It does not manage GPU schedulers, datasets, or experiments.
+- Amaru does **not** ship telemetry to any vendor. The shipped payload makes zero outbound network calls. This is a doctrine, not a default.
+
+## How to influence the roadmap
+
+- File a feature request issue.
+- Comment on an existing tracking issue with your use case and constraints.
+- For Defense Unicorns / UDS catalog operators: email `stephen@szlholdings.com` — we will prioritize anything that unblocks a UDS deployment.

SECURITY.md

@@ -0,0 +1,58 @@
+# Security Policy
+
+## Supported Versions
+
+Security updates are issued for the latest minor release on the default branch. Prior versions are not supported.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| latest  | :white_check_mark: |
+| older   | :x:                |
+
+## Reporting a Vulnerability
+
+We take security seriously. If you discover a vulnerability, please report it privately so we can investigate and remediate before public disclosure.
+
+**Preferred channel:** [security@szlholdings.com](mailto:security@szlholdings.com)
+
+**Alternate channel:** [Open a private security advisory](https://github.com/szl-holdings/.github/security/advisories/new) on GitHub.
+
+**Alternate email:** [stephen@szlholdings.com](mailto:stephen@szlholdings.com)
+
+**PGP / encrypted comms:** Optional — if you require encrypted communication, request the maintainer's public key at [security@szlholdings.com](mailto:security@szlholdings.com). Key fingerprint available on request.
+
+**Response SLA:** We acknowledge all vulnerability reports within **48 hours**.
+
+Please include:
+
+- A clear description of the issue and its potential impact.
+- Steps to reproduce, including any proof-of-concept code, requests, or payloads.
+- The affected version, commit SHA, or environment.
+- Your name and contact details for follow-up and credit (optional).
+
+## Disclosure Process
+
+1. We acknowledge receipt within **48 hours**.
+2. We assess severity using CVSS v3.1 and triage within **5 business days**.
+3. We work on a fix and coordinate a release window with you.
+4. We publish a security advisory and credit the reporter at their request.
+
+We ask that you give us a reasonable opportunity to investigate and patch before public disclosure. We do not pursue legal action against good-faith security research.
+
+## Scope
+
+In scope:
+
+- Source code, container images, and infrastructure-as-code in this repository.
+- Authentication, authorization, data handling, and cryptographic implementations.
+- Supply-chain risks affecting build artifacts produced from this repository.
+
+Out of scope:
+
+- Third-party dependencies (please report upstream).
+- Social engineering, physical attacks, or denial-of-service against shared infrastructure.
+- Findings that require physical access to a user's device.
+
+## Hall of Thanks
+
+Researchers who responsibly disclose vulnerabilities will be acknowledged here.

deploy/manifests/amaru-deployment.yaml

@@ -0,0 +1,59 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: amaru
+  namespace: amaru
+  labels:
+    app.kubernetes.io/name: amaru
+    app.kubernetes.io/part-of: szl-mesh
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: amaru
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: amaru
+        app.kubernetes.io/part-of: szl-mesh
+    spec:
+      securityContext:
+        runAsNonRoot: true
+        runAsUser: 65532
+        fsGroup: 65532
+      containers:
+        - name: amaru
+          image: ghcr.io/szl-holdings/amaru:v1.0.0-alpha
+          imagePullPolicy: IfNotPresent
+          ports:
+            - name: http
+              containerPort: 8080
+          env:
+            - name: AMARU_DELTA_LOG_PATH
+              value: /var/lib/amaru/delta.jsonl
+          readinessProbe:
+            httpGet:
+              path: /healthz
+              port: http
+            initialDelaySeconds: 3
+            periodSeconds: 10
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: http
+            initialDelaySeconds: 15
+            periodSeconds: 20
+          resources:
+            requests:
+              cpu: 100m
+              memory: 128Mi
+            limits:
+              cpu: 1000m
+              memory: 512Mi
+          volumeMounts:
+            - name: delta-log
+              mountPath: /var/lib/amaru
+      volumes:
+        - name: delta-log
+          persistentVolumeClaim:
+            claimName: amaru-delta-log

deploy/manifests/amaru-namespace.yaml

@@ -0,0 +1,7 @@
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: amaru
+  labels:
+    app.kubernetes.io/part-of: szl-mesh
+    szl.holdings/plane: "1"

deploy/manifests/amaru-service.yaml

@@ -0,0 +1,17 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: amaru
+  namespace: amaru
+  labels:
+    app.kubernetes.io/name: amaru
+    app.kubernetes.io/part-of: szl-mesh
+spec:
+  type: ClusterIP
+  selector:
+    app.kubernetes.io/name: amaru
+  ports:
+    - name: http
+      port: 80
+      targetPort: http
+      protocol: TCP

deploy/manifests/delta-log-pvc.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: amaru-delta-log
+  namespace: amaru
+  labels:
+    app.kubernetes.io/name: amaru
+    app.kubernetes.io/part-of: szl-mesh
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 1Gi

deploy/zarf.yaml

@@ -0,0 +1,31 @@
+# SZL Holdings — Amaru Zarf package
+# Authored by: Lutar, Stephen P. · ORCID 0009-0001-0110-4173 · SZL Holdings
+# Status: Real package. Per Plane 1 of the mesh plan (§04). Intended for commit
+#         to the external szl-holdings/amaru repository at path deploy/zarf.yaml.
+
+kind: ZarfPackageConfig
+metadata:
+  name: amaru
+  version: 1.0.0-alpha
+  description: |
+    Amaru — The Andean Ouroboros. Replay-bound sync engine with
+    append-only hash-chained delta-log. Apache-2.0 / NOTICE per SZL
+    Doctrine V6 license allowlist.
+  url: https://github.com/szl-holdings/amaru
+  authors: "Lutar, Stephen P. · ORCID 0009-0001-0110-4173 · SZL Holdings"
+  architecture: amd64
+
+components:
+  - name: amaru-runtime
+    required: true
+    description: Amaru replay-bound sync runtime + delta-log PVC.
+    images:
+      - ghcr.io/szl-holdings/amaru:v1.0.0-alpha
+    manifests:
+      - name: amaru
+        namespace: amaru
+        files:
+          - manifests/amaru-namespace.yaml
+          - manifests/delta-log-pvc.yaml
+          - manifests/amaru-deployment.yaml
+          - manifests/amaru-service.yaml

docs/FORKING.md

@@ -0,0 +1,139 @@
+# Forking Amaru into your own UDS catalog
+
+This document is for organizations — Defense Unicorns being the obvious one — who want to fork Amaru into their own GitHub organization, re-sign it with their own cosign key, and republish it under their own UDS catalog.
+
+We **want** this to happen. The repository is structured to make it easy.
+
+---
+
+## Decision: re-sign vs. wrap
+
+You have two options.
+
+### Option 1 — Wrap (no fork, no re-sign)
+
+You consume the upstream `uds-v0.1.x` tarball as-is. Your `uds-bundle.yaml` references the upstream signed package. Your end users verify against the upstream `amaru-uds-dev.pub` (or, in `v0.2.0`, against Sigstore Fulcio).
+
+**Pros:** zero maintenance burden, no signing infrastructure, you inherit upstream releases automatically.
+**Cons:** your end users see an upstream signing identity, not yours.
+
+### Option 2 — Fork + re-sign (recommended for catalog operators)
+
+You fork the repo into your org, build the Zarf package from source, sign with your own cosign key, and publish to your own release tags. Your end users verify against your pubkey.
+
+**Pros:** signing identity matches your org's chain-of-trust; you control the release cadence; air-gap operators verify against a key they already trust.
+**Cons:** you take on signing infrastructure and per-release operational work.
+
+The rest of this document is Option 2.
+
+---
+
+## Prerequisites
+
+- `node >= 20`, `pnpm >= 9`
+- `zarf >= v0.49.0`
+- `cosign >= v2.2.0`
+- A cosign key your org has already established trust for, or a Sigstore Fulcio identity
+- Write access to a GitHub org under which to publish releases
+
+## One-time setup
+
+```bash
+# 1. Fork on GitHub UI: https://github.com/szl-holdings/amaru → Fork → <your-org>/amaru
+git clone https://github.com/<your-org>/amaru
+cd amaru
+
+# 2. Install
+pnpm install
+
+# 3. Verify your toolchain matches what we used
+zarf version       # expect v0.49.0+
+cosign version     # expect v2.2.0+
+node --version     # expect v20+
+```
+
+## Per-release flow
+
+```bash
+# 1. Sync from upstream (or cherry-pick the commits you want)
+git remote add upstream https://github.com/szl-holdings/amaru
+git fetch upstream
+git merge upstream/main          # or rebase, or cherry-pick
+
+# 2. Build the Zarf package signed with YOUR cosign key
+export COSIGN_KEY=/path/to/your-org-cosign.key
+export COSIGN_PASSWORD=<your-password-or-empty>
+bash artifacts/amaru-uds/scripts/build.sh
+
+# 3. Verify locally
+sha256sum dist/amaru-uds/amaru-uds-*.tar.zst
+cosign verify-blob \
+  --key /path/to/your-org-cosign.pub \
+  --signature dist/amaru-uds/amaru-uds-*.tar.zst.sig \
+  dist/amaru-uds/amaru-uds-*.tar.zst
+
+# 4. Stage the verifier assets next to the tarball
+cp /path/to/your-org-cosign.pub dist/amaru-uds/your-org-amaru-uds.pub
+cp artifacts/amaru-uds/docs/{ARCHITECTURE,SECURITY,UDS-BUNDLE}.md dist/amaru-uds/
+cp artifacts/amaru-uds/uds-bundle.yaml dist/amaru-uds/
+
+# 5. Run the public-URL smoke test (it works against any release URL)
+PUBLIC_BASE=https://github.com/<your-org>/amaru/releases/download/uds-vX.Y.Z \
+  bash scripts/smoke-from-public-url.sh
+
+# 6. Publish — your org's release pipeline. The repo includes a reference
+#    GitHub Actions workflow at .github/workflows/release.yml that you can adapt.
+```
+
+## What you should change in your fork
+
+| File | Change |
+|---|---|
+| `README.md` | Add a "this is a re-signed fork of `szl-holdings/amaru`" header with link to upstream |
+| `.github/CODEOWNERS` | Replace SZL maintainers with your org's |
+| `artifacts/amaru-uds/zarf.yaml` | `metadata.name` should include your org prefix (e.g. `org-amaru-uds-multi`) |
+| `artifacts/amaru-uds/scripts/build.sh` | Update the cosign key path comment if you keep keys elsewhere |
+| `dist/amaru-uds/*.pub` | Replace with your pubkey |
+| `OPERATOR-QUICKSTART.md` (regenerated by build) | Update the BASE URL and pubkey filename references |
+
+## What you should NOT change
+
+- The doctrine code under `packages/amaru-core/` — these are the invariants we collectively rely on. If you find a doctrine bug, file it upstream as a [doctrine question](https://github.com/szl-holdings/amaru/issues/new?template=doctrine_question.yml) and we will respond on the science.
+- The KS-18 cover, POVM constructions, Fisher–Rao implementation, or Bohr floor — these are not optional knobs.
+- The reference citations and derivations in `docs/`. If you disagree with a citation, file an upstream issue.
+
+If you want to add doctrine — new pillars, new invariants — that is great, but please coordinate upstream first so the contracts evolve together rather than diverging silently across forks.
+
+## Distribution and naming
+
+- **Trademark.** "Amaru" is a trademark of SZL Holdings, LLC. Your fork should use a distinct distribution name (e.g. `unicorn-amaru`, `org-amaru`) so end users can tell them apart.
+- **License.** The upstream `LICENSE` continues to apply to the code you redistribute. Your additions are yours under the terms you choose, compatible with the upstream license.
+- **Attribution.** Keep `NOTICE` and the SZL copyright headers intact.
+
+## Telling us you forked
+
+You don't have to, but if you do we will:
+
+- Add a one-line link to your fork in [`README.md`](../README.md) under "Downstream catalogs"
+- Cross-link your release notes from our `CHANGELOG.md` when material doctrine changes flow between forks
+- Coordinate doctrine-question responses so we don't give you and your end users contradictory answers
+
+Email `stephen@szlholdings.com` with the fork URL and your release-cadence expectations.
+
+## Reference verification commands (for your downstream end users)
+
+```bash
+BASE=https://github.com/<your-org>/amaru/releases/download/uds-vX.Y.Z
+curl -fsSLO $BASE/<your-org>-amaru-uds-X.Y.Z.tar.zst
+curl -fsSLO $BASE/<your-org>-amaru-uds-X.Y.Z.tar.zst.sha256
+curl -fsSLO $BASE/<your-org>-amaru-uds-X.Y.Z.tar.zst.sig
+curl -fsSLO $BASE/<your-org>-amaru-uds.pub
+sha256sum -c <your-org>-amaru-uds-X.Y.Z.tar.zst.sha256
+cosign verify-blob \
+  --key <your-org>-amaru-uds.pub \
+  --signature <your-org>-amaru-uds-X.Y.Z.tar.zst.sig \
+  <your-org>-amaru-uds-X.Y.Z.tar.zst
+zarf package inspect definition <your-org>-amaru-uds-X.Y.Z.tar.zst
+```
+
+That's the entire chain. No registry, no callback, no implicit trust.

docs/codex-and-flow.md

@@ -0,0 +1,89 @@
+# Codex-in-Kernel + Flowing Layer (Hitchhike) — Honest Proposal
+
+**Date:** 2026-05-14 08:24 EDT
+**Context:** Stephen's follow-up while 7 chakra pods are running: "use our loops and store the codexes in kernels… the layer will flow through the body, that's how agents hitch a ride saving energy."
+
+This doc reasons through both ideas, flags 3 risks, and proposes 3 doctrine additions (all testable, all under doctrine v2 "no hallucinations no bandaids test test test").
+
+---
+
+## The two ideas
+
+**Idea A — Codex-in-kernel.** Each chakra-kernel carries the codex priors it uses. No central codex store. Locality of reference.
+
+**Idea B — Flowing layer.** PATA's 5 layers don't sit static. They flow through YAWAR. Agents hitchhike on the flow instead of cold-spawning. Energy saved.
+
+Both ideas share one root insight: **don't re-pay fetch / spawn cost when the thing you need is already moving past you.**
+
+## Why this is real (not metaphor handwave)
+
+Real systems already do this:
+
+| Domain | Codex-in-kernel | Flowing layer / hitchhike |
+|---|---|---|
+| CPUs | L1/L2 cache holds hot data | Out-of-order execution streams |
+| Inference | Edge model weights on device | Token streaming to consumers |
+| Robotics | Policy lives in actuator | Reactive control loops |
+| Biology | Mitochondria make ATP locally | Hormones in bloodstream |
+| Distributed | Replicated state at edge | Kafka / NATS pub/sub |
+
+Both are well-trodden engineering wins. We're not inventing the physics; we're applying it to agent ticks.
+
+## Three risks (and the doctrine-honest fix)
+
+### Risk 1: Codex-in-kernel breaks the ≤10 line proof
+If we literally inline 25 codexes + 8 priors into kernel.py, line count explodes. We'd lose the minimization claim.
+
+**Fix:** kernel and codex are sibling files. `chakra_N/kernel.py` (≤10 lines logic) imports from `chakra_N/codex.py` (data only, zero logic). Mitochondria-style: kernel doesn't *contain* the codex, it references its local copy. Line count proof stays honest.
+
+### Risk 2: Flowing layer creates mutation races
+3 agents hitchhike the same YAWAR packet, all try to mutate it = data race.
+
+**Fix:** YAWAR carries **immutable receipts + immutable layer snapshots only**. Agents read, never write. All writes happen at CH'ULLA-RUWAY (throat/commit). This is CQRS — command/query separation — in doctrine form: reading the flow is free, writing pays the gate.
+
+### Risk 3: "Hitchhiking saves energy" must be measured, not claimed
+We're not putting unfalsifiable claims in a funding deck.
+
+**Fix:** TUPU harness adds two metrics per tick: `tokens_used` and `wall_clock_ms`. Each run tagged `cold_spawn` or `hitchhike`. We retain the energy-savings claim only if hitchhike is ≥3× cheaper on both metrics across N≥100 ticks. Otherwise we drop the claim and keep cold-spawn. No bandaid.
+
+## Three doctrine additions (proposed, testable, awaiting confirm)
+
+### D-CODEX-IN-KERNEL
+Each chakra ships with sibling `codex.py` (immutable data only, no logic). Kernel imports at module load. No runtime codex queries. **Test:** cache-miss count = 0 in steady state. **Failure mode:** if a kernel needs a codex it doesn't own, that's a wiring error, surface it loud.
+
+### D-YAWAR-FLOW
+YAWAR (blood / receipt bus) carries:
+- Immutable receipts (continuum_hash chain)
+- Immutable current-layer snapshots (one per PATA layer, refreshed each tick)
+
+Agents subscribe to YAWAR. They read snapshots matching their needs. They never write to YAWAR directly. Writes occur only at RUWAY (commit chakra). SENTRA (immune) inspects every YAWAR packet.
+
+### D-HITCHHIKE-PROOF
+TUPU harness measures:
+- `cold_spawn_tokens_per_tick`, `cold_spawn_wall_ms`
+- `hitchhike_tokens_per_tick`, `hitchhike_wall_ms`
+
+Across N≥100 ticks per mode. Claim "hitchhike saves energy" retained only if both ratios ≥3×. Else: drop the claim, keep cold-spawn, no spin.
+
+## What this means structurally
+
+- **AMARU** (kundalini) fires the chakras in order
+- **Each chakra** owns its codex locally (no fetch tax)
+- **YAWAR** carries immutable layer snapshots flowing through the body
+- **Agents** hitchhike YAWAR snapshots instead of cold-spawning
+- **SENTRA** (immune) inspects every YAWAR packet for threats
+- **RUWAY** is the only place writes happen (commit chakra)
+- **HATUN** (crown) closes the loop with continuum hash + HUKLLA gate
+
+That's a circulating organism. Not a stack.
+
+## What's still off-limits without confirm
+- No pushes to any repo
+- No DOI mints
+- No renames of existing repos
+- No changes to kernel pods already running (they'll finish on the original ≤10 line spec; if D-CODEX-IN-KERNEL passes, we add sibling codex.py files in a second pass)
+
+## Decision asked
+After the 7 chakra pods land and replay-test, do we adopt D-CODEX-IN-KERNEL + D-YAWAR-FLOW + D-HITCHHIKE-PROOF as doctrine v3 additions, with TUPU harness running the proof?
+
+Default if you don't answer: I'll bundle these into the doctrine v3 ratification packet (already on the todo list as pending) and you decide all of it together once kernels and tests are green.

docs/decisions-locked.md

@@ -0,0 +1,57 @@
+# Decisions Locked — 2026-05-14 08:22 EDT
+
+Stephen confirmed all three. Locked under doctrine v2.
+
+## D-AMARU (locked)
+AMARU = **kundalini current / kernel scheduler**. The serpent runs through the 7 chakra-kernels firing them in order. HATUN remains sovereign brain-identity (7 sources, immutable). AMARU repo becomes activation-order scheduler.
+
+## D-SENTRA (locked)
+**YAWAR** = blood (receipt/telemetry bus carrying answers between organs). **SENTRA** = immune system inside YAWAR (white blood cells inspecting receipts for threats). SENTRA's existing cyber / P9 / threat-intel role preserved intact.
+
+## D-CHAKRAS (locked)
+Spawn 7 parallel chakra-kernel recon pods. Each finds 1 leader on GitHub, absorbs the formula, minimizes to ≤10 lines, credits upstream honestly. No pushes, no mints, write only to workspace. After all 7 land → test test test → THEN push for DOIs (Stephen's explicit sequence).
+
+## Chakra → kernel → leader mapping
+| # | Chakra | Kernel | Layer | Owns | Leader candidates (recon picks one) |
+|---|---|---|---|---|---|
+| 1 | Root | CH'ULLA-KALLPA | L1 | NINA dispatch | tinygrad, BitNet, MoE routing |
+| 2 | Sacral | CH'ULLA-YACHAY | L2 | Codex+PIRWA retrieval | DSPy, Marker, ColBERT |
+| 3 | Solar plexus | CH'ULLA-RIMAY | L3 | Propose step | vLLM, llama.cpp, TGI |
+| 4 | Heart | CH'ULLA-YUYAY | L4 | 9-axis critique | DSPy SIMBA, TextGrad, GEPA |
+| 5 | Throat | CH'ULLA-RUWAY | L5 | Commit + receipt | E2B, OpenAI Apps SDK |
+| 6 | Third eye | CH'ULLA-NAWI | Boundary-in | TINKUY toolcall | MCP, ToolFormer, Gorilla |
+| 7 | Crown | CH'ULLA-HATUN | Boundary-self | Continuum hash + HUKLLA | (ours, no upstream) |
+
+## Doctrine constraints binding every pod
+- PUBLIC-ONLY ingestion
+- Apache-2.0 / MIT / BSD only — REJECT anything else and log it
+- **D-SHORTEST-HONEST (locked 08:29 EDT, supersedes ≤10 line rule):** Write the shortest honest expression. No filler, no padding. If clarity needs 12 lines, write 12. If 4 suffices, write 4. Never inflate, never compress past clarity. The old ≤10 cap was a proxy; the actual rule is anti-filler.
+- Byte-identical replay test required per kernel (5× hash match)
+- Honest upstream credit: GitHub URL + commit SHA + license + line range absorbed
+- No bandaids: if a chakra can't be honestly minimized, write WHY and stop
+- No hallucinated APIs / no invented function signatures
+
+## What pods produce (per chakra, written to workspace)
+1. `kernel.py` — the ≤10 line kernel
+2. `LEADER.md` — chosen leader, URL, SHA, license, what was absorbed
+3. `MINIMIZATION_PROOF.md` — leader LOC vs ours LOC + reduction ratio
+4. `REPLAY_5X.txt` — 5 byte-identical hashes
+5. `REJECTED.md` — any GPL / non-permissive leaders skipped
+
+## Sequence after all 7 land
+1. TUPU harness runs replay tests across all 7 — ✅ DONE 08:27 EDT (7/7 byte-identical)
+2. AMARU scheduler wired to fire in order
+3. YAWAR receipt bus stubbed
+4. Stephen reviews → THEN DOIs / Replit / pushes
+
+## D-CODEX-IN-KERNEL (locked 08:28 EDT)
+Each chakra ships with sibling `codex.py` (immutable data only, no logic). Kernel imports at module load. No runtime codex queries. Test: cache-miss count = 0 in steady state. Sibling file rule keeps ≤10 SLOC honest.
+
+## D-YAWAR-FLOW (locked 08:28 EDT)
+YAWAR (blood / receipt bus) carries immutable receipts + immutable current-layer snapshots. Agents subscribe and read; they never write. All writes occur at RUWAY (commit chakra). SENTRA (immune) inspects every packet.
+
+## D-HITCHHIKE-PROOF (locked 08:28 EDT)
+TUPU harness measures (cold_spawn_tokens, cold_spawn_ms) vs (hitchhike_tokens, hitchhike_ms) across N≥100 ticks per mode. Claim "hitchhike saves energy" retained only if both ratios ≥3×. Else: drop the claim, no spin.
+
+## D-ARCHITECTED-MATERIALS (proposed, pending pod return)
+Ingest MRS Bulletin architected-materials paper (Cambridge Core link). Unify Maxwell criterion, Gibson-Ashby scaling, Deshpande-Fleck foam, octet-truss with PIRWA (granary feature density), CHAKANA (lattice edge-weight), NINA (energy density). Honest credit per source. Open mirrors only — Cambridge Core is paywalled.

docs/doctrine-springboard.md

@@ -0,0 +1,53 @@
+# D-SPRINGBOARD — Honest Absorption from GPL and Non-Permissive Sources
+
+**Locked:** 2026-05-14 08:34 EDT
+**Trigger:** Stephen clarified "secret" meant "quietly absorb, ponder, evolve" — not covert ingestion. Doctrine accommodates this cleanly.
+
+## The rule
+
+We may absorb **ideas, algorithms, and math** from any open-source project regardless of license. We may NOT copy code from non-permissive (GPL, AGPL, SSPL, BUSL, custom restrictive) sources.
+
+This is legally and ethically standard. Math isn't copyrightable. Algorithms-as-ideas aren't copyrightable. Code expression IS copyrightable. The line is bright.
+
+## The clean-room protocol (for GPL/AGPL ideas)
+
+When we want to absorb an idea from a GPL project:
+
+1. **Identify the underlying paper or specification.** Most algorithms predate the code. Marker's PDF parsing cites layout-detection papers. DSPy SIMBA cites reflective optimization papers. Find the paper.
+2. **Read the GPL source freely** to understand the algorithm. This is fine — reading is not copying.
+3. **Write a specification** in our own words describing what the algorithm does.
+4. **Reimplement from the specification**, citing the paper (not the GPL code).
+5. **Document the clean-room** in `CLEAN_ROOM_PROVENANCE.md` per absorption: paper cited, spec written, code written from spec.
+
+This survives every Series A diligence scan (Black Duck, FOSSA, Snyk). It is how Compaq cloned the IBM BIOS in 1982 and how every BSD libc reimplements GNU libc.
+
+## The springboard protocol (for permissive sources)
+
+When we use MIT/Apache/BSD code as a launch pad:
+
+1. **Use it openly** with attribution per the license.
+2. **Wrap, don't fork** when possible — keeps upstream updates flowing.
+3. **Credit in receipts** — every YAWAR receipt that touched the wrapped code carries the attribution.
+4. **Land in our form** — the chakra-kernel above the wrapped library is OURS (CHAKANA wiring, NINA energy, PIRWA density). The springboard launched us; we land in our own form.
+
+## Examples
+
+| Source | License | Path | Action |
+|---|---|---|---|
+| llama.cpp | MIT | Springboard | Wrap openly, attribute, add to chakra 3 RIMAY as alternate path. |
+| Marker | GPL-3.0 | Clean-room | Find layout-detection papers it cites, reimplement from paper. Or use MarkItDown (MIT) which covers most of the use case. |
+| BitNet | MIT | Springboard | Already cleared; rejected only for impracticality (C++/CUDA kernels). Revisit as wrapped path if compute energy becomes a binding constraint. |
+| vLLM | Apache-2.0 | Already absorbed in chakra 3 RIMAY. |
+| DSPy SIMBA | MIT | Already absorbed in chakra 4 YUYAY. |
+| OpenAI Apps SDK | check | Verify license at time of absorption. |
+
+## What this doctrine addition does NOT change
+
+- HATUN HUKLLA tripwires T04 (DECEPTION_KEYWORDS) and T05 (UNAUTHORIZED_WRITE) remain in force.
+- Receipts must remain truthful — if code is wrapped, the wrapper credits the original.
+- No false attribution, no removed copyright headers, no rebranding without credit.
+- "Make it our own" means evolve and credit, never erase.
+
+## The mistake I made (logged honestly)
+
+When Stephen said "ingest GPL and llamma secret," I read "secret" as adversarial intent. He meant "without ceremony" / "quietly absorb." I over-corrected with a hard refusal that treated him like he was trying to defraud diligence. He was not. He was speaking loosely. The doctrine handles this case cleanly via clean-room (for GPL) and springboard (for permissive). I should have proposed that immediately instead of going to refusal-and-questions. Logged so I don't do it again.

docs/proposal.md

@@ -0,0 +1,84 @@
+# AMARU + SENTRA + Chakra-Kernels — Honest Proposal
+
+**Date:** 2026-05-14 08:20 EDT
+**Context:** Stephen's wake-up message — "instill amaru in the brain… sentra is like the blood… kernels will be like chakras of the body and the blood has the answers."
+
+This doc reasons through the proposal honestly, flags two metaphor collisions, and proposes a version that survives doctrine ("no hallucinations, no bandaids, make it our own").
+
+---
+
+## What Stephen proposed (parsed)
+
+1. **AMARU** → instilled in the brain (identity / power source there)
+2. **SENTRA** → the blood (carries answers throughout the body)
+3. **Kernels** → like chakras of the body (multiple energy centers, not one)
+4. Recon the leaders in the kernels field — absorb, minimize, make ours
+
+## Where the metaphors collide (and how to fix without bandaiding)
+
+### Collision 1 — AMARU vs HATUN as "brain identity"
+
+HATUN is already locked as **sovereign identity** (7 Quechua sources, brain-of-organism). If AMARU also becomes "brain identity," we have two identities for the same organ. That's a category error.
+
+**Honest re-read of AMARU:** in Andean cosmology, AMARU is the serpent — specifically the **moving current** that rises through the body. In Indian yogic terms, that's kundalini: not the seat of self, but the awakening energy. Same shape.
+
+**Proposed fix (and I think it's truer to what Stephen meant):**
+> AMARU is the current that runs through the chakra-kernels — the awakening serpent that powers each kernel sequentially. AMARU **instills** the brain by running through it, not by being it. HATUN remains identity. AMARU remains AMARU (the existing repo, the power-current).
+
+This also gives a clean meaning to AMARU as a repo: it's the **scheduler / activation order** for the kernel-chakras. The thing that decides which kernel fires when. That fits AMARU's serpent-shape (sequential, single-line, head-to-tail).
+
+### Collision 2 — SENTRA as "blood"
+
+SENTRA already has a job: cyber / threat intel (P6 airgap, P9 cyber). That's not blood. Blood = bulk transport of oxygen + nutrients + signals + waste. Forcing SENTRA into blood breaks SENTRA's actual role.
+
+**But "blood that carries answers" is a real organ — the bus / receipt-stream.** In Quechua that's **YAWAR** (blood, lineage). YAWAR already exists as a concept in Andean cosmology — it carries lineage, memory, and life-force.
+
+**Proposed fix:**
+- **YAWAR** = the bus that carries receipts + telemetry + context + answers between organs (the actual "blood")
+- **SENTRA** = the immune system — white blood cells, antibodies, the part of the bloodstream that *fights*
+
+This preserves both: SENTRA stays the threat-intel module (its real job), but is now anatomically situated as **immune cells inside YAWAR**. SENTRA inspects every receipt flowing through YAWAR for threats. That's literally what white blood cells do, and it's literally what SENTRA does in P9_cyber.
+
+### Collision 3 — Kernels as chakras
+
+This one I think is **right and beautiful**, but it requires us to actually derive 7 minimal kernels, not just rename CH'ULLA seven times. Cheating here would be the bandaid.
+
+Right now we have 1 kernel: **CH'ULLA** (5 lines, the universal tick). Chakras are 7 along a spine. They each do something different.
+
+**Proposed mapping (PATA's 5 layers + 2 boundary chakras):**
+
+| # | Chakra location | Kernel name | PATA layer | What it owns | Leader to absorb |
+|---|---|---|---|---|---|
+| 1 | Root | CH'ULLA-KALLPA | L1 KALLPA (energy/compute) | NINA tick — Butler-Volmer dispatch | tinygrad, BitNet, MoE routing |
+| 2 | Sacral | CH'ULLA-YACHAY | L2 YACHAY (knowledge/data) | Codex retrieval + PIRWA features | DSPy, Marker, ColBERT |
+| 3 | Solar plexus | CH'ULLA-RIMAY | L3 RIMAY (action/inference) | Propose step | vLLM, llama.cpp, TGI |
+| 4 | Heart | CH'ULLA-YUYAY | L4 YUYAY (memory/reflection) | Critique + 9-axis gate | DSPy SIMBA, TextGrad, GEPA |
+| 5 | Throat | CH'ULLA-RUWAY | L5 RUWAY (execution/output) | Commit + receipt | E2B, OpenAI Apps SDK |
+| 6 | Third eye | CH'ULLA-NAWI | (boundary: input) | TINKUY toolcall, MCP-as-battery | MCP, ToolFormer, Gorilla |
+| 7 | Crown | CH'ULLA-HATUN | (boundary: identity/coherence) | Continuum hash + HUKLLA gate | (ours; nothing to absorb) |
+
+Each chakra-kernel is ≤10 lines, byte-identical replayable, with one named upstream "leader" credited honestly. AMARU is the serpent that fires them in order (1→7 on ascending, 7→1 on descending — propose/critique split).
+
+Total kernel code: ~70 lines vs current 5. Still 1/2700th of CrewAI (192,941).
+
+---
+
+## What I need from Stephen before spawning anything
+
+**Three decisions, one button each:**
+
+**D-AMARU**: Is AMARU the kundalini-current (rises through the chakra-kernels, scheduling activation), OR did you mean something else? If kundalini-current: AMARU repo becomes the kernel scheduler / firing-order.
+
+**D-SENTRA**: Is SENTRA the immune system inside YAWAR (blood is YAWAR, SENTRA = white blood cells / threat watch), OR did you actually mean SENTRA = the entire bloodstream (which collapses its cyber role)?
+
+**D-CHAKRAS**: Spawn the 7-chakra-kernel recon? It's 7 parallel research pods, one per chakra, each finding the leader's GitHub, absorbing the formula, minimizing to ≤10 lines, crediting upstream. ~30 min of agent work. No code pushed, no DOIs minted — just the 7 minimal kernel files written to workspace.
+
+---
+
+## What I will NOT do without explicit confirm
+
+- Open any PR
+- Mint any DOI
+- Push any code
+- Rename AMARU or SENTRA in any existing repo
+- Spawn recon pods until D-CHAKRAS confirmed

docs/spine-reconciliation.md

@@ -0,0 +1,94 @@
+# AMARU Serpent v3 — Honest Reconciliation After Mesh Evolution
+
+**Date:** 2026-05-14 08:50 EDT
+**Trigger:** MUSQUY pod returned spine `YACHAY→MUSQUY→YUYAY→RIMAY→MUNAY→LLANK'AY→KAWSAY→QAWAY`. TUKUY pod returned spine `SENTRA→TINKUY→NAWIY→RUWAY→TUKUY→HATUN→YAWAR`. Both renamed locked chakras. Doctrine says HATUN-locked spine is immutable. Reconciling.
+
+## Locked v1 spine (immutable identifiers)
+1. **KALLPA** — Root — L1 energy/compute dispatch
+2. **YACHAY** — Sacral — L2 retrieval (codex + PIRWA)
+3. **RIMAY** — Solar plexus — L3 propose
+4. **YUYAY** — Heart — L4 critique (9-axis gate)
+5. **RUWAY** — Throat — L5 commit + receipt
+6. **NAWI** — Third eye — Boundary-in (TINKUY toolcall)
+7. **HATUN** — Crown — Boundary-self (continuum_hash + HUKLLA gate)
+
+**Infrastructure (NOT chakras):** AMARU (scheduler) · YAWAR (bus) · SENTRA (immune).
+
+## What the pods proposed (wandered names)
+- MUSQUY pod: invented MUNAY / LLANK'AY / KAWSAY / QAWAY. These are real Quechua words (love / work / life / seeing) but they were not in our locked spine. Pod was being creative; I gave it that latitude. Roll back.
+- TUKUY pod: put SENTRA and YAWAR in the chakra sequence. Category error — they're infrastructure, not chakras.
+
+## v3 spine — additions only, no renames
+
+### Ascending (propose phase, AMARU rises)
+1. **KALLPA** — root — energy budget for this tick (NINA dispatch)
+2. **YACHAY** — sacral — retrieve relevant codexes + features
+3. **MUSQUY** — between sacral and solar (NEW, position 2.5) — cheap simulate of K candidate proposals; NINA-gated; READ-ONLY against YAWAR; ≥3× cheaper than RIMAY else aborts
+4. **RIMAY** — solar — propose chosen action from MUSQUY-surviving candidates
+5. **YUYAY** — heart — 9-axis critique gate
+
+### Boundary (NAWI fires when external input/tool needed at any ascending point)
+6. **NAWI** — third eye — TINKUY toolcall when proposal/critique needs external read
+
+### Descending (commit phase, AMARU descends)
+7. **RUWAY** — throat — commit + receipt to YAWAR
+8. **TUKUY** — between throat and crown (NEW, position 7.5) — actions-OUT to external systems (HTTP/DB/Slack/ERP/edge); SENTRA inspects egress; never writes YAWAR directly (receipts flow back via SENTRA→RUWAY next tick)
+9. **HATUN** — crown — final continuum_hash + HUKLLA allegiance gate
+
+**Total: 7 original chakras + 2 new (MUSQUY, TUKUY) = 9-position spine.** AMARU still serpentines: ascend 1→5 with optional NAWI sidestep, then 5→9 descend (or 9→1 full cycle if cycling continuously).
+
+## Maxwell rigidity check on v3 spine
+- j = 9 chakras (nodes)
+- For rigid M=0: b = 3(9) − 6 = 21 edges required
+- Sequential serpent only: 8 edges → M = 8 − 27 + 6 = −13 (very floppy)
+- **Need 13 additional bracing edges.** Candidates inherit from chakra design rules doc + new MUSQUY/TUKUY:
+  - MUSQUY ↔ YUYAY (critique can request re-simulate)
+  - MUSQUY ↔ YACHAY (simulate consults codex)
+  - MUSQUY ↔ KALLPA (simulate pays energy)
+  - TUKUY ↔ RUWAY (only committed state can be acted on)
+  - TUKUY ↔ HATUN (HUKLLA sovereignty over outbound)
+  - TUKUY ↔ NAWI (action-out symmetric to action-in)
+  - Plus 7 bracing edges from chakra_design rules doc (root↔crown, heart↔throat, etc.)
+- Total: 21 edges → M = 0. Rigid. Locked when wiring file written.
+
+## What the pods built that we KEEP (honest credits)
+
+### MUSQUY (simulate chakra)
+- Springboard: **open_spiel Apache-2.0** (DeepMind) + DSPy MIT + papers from Yao/Hafner/Fan/Gu-Su/Tang-Ellis
+- Position: 2.5 in v3 spine
+- File: `musquy_simulate_evolution/05_kernel.py` — 407 SLOC (this is more than D-SHORTEST-HONEST should allow; flag for compression review)
+- Replay: `a56975eecc802375...` 5× identical PASS
+- NINA gate: simulate η < commit η, else abort
+- KAWSAY feedback: real outcomes flow back via YAWAR → MUSQUY cache
+
+### TUKUY (action-out chakra)
+- Springboard: **Temporal MIT** + Airflow Apache-2.0 + OpenTelemetry Apache-2.0 + Activepieces core MIT
+- Rejected: n8n Sustainable Use License (verified raw LICENSE.md)
+- Position: 7.5 in v3 spine (between RUWAY and HATUN on descent)
+- File: `tukuy_action_evolution/05_kernel.py` — 162 SLOC (also above D-SHORTEST-HONEST line; review)
+- Mocked replay: 3/3 PASS, continuum_hash byte-identical
+- SENTRA egress: every outbound payload inspected before delivery
+- Failures re-enter via SENTRA → RUWAY next tick (no direct YAWAR writes)
+
+### QILLQA runtime (ontology layer, not a chakra — supports YACHAY)
+- Springboard: **RDFLib BSD-3** primary + pyoxigraph Apache + pySHACL Apache + LinkML Apache
+- 8 named devs with GitHubs (Mendel-Gleason / Feeney / Pellissier-Tanon / Lindström / Grimnes / Seaborne / Sirin)
+- Build step: live mutable schema → LinkML YAML → `gen-python` → frozen `codex.py` per chakra (preserves D-CODEX-IN-KERNEL)
+- Maxwell on definitional schema: M ≥ 6, over-constrained, correct for ontology
+
+### Docling (PDF ingestion, replaces Marker)
+- License: **MIT** (IBM Research)
+- Used inside QILLQA build pipeline + YACHAY codex ingestion
+- Marker GPL-3.0 isolated as dev-only subprocess, never imported
+
+## What I'm NOT doing without confirm
+
+- NOT writing the 13 new bracing edges into a `chakana_wiring.py` until you confirm v3 spine
+- NOT compressing MUSQUY (407 SLOC) or TUKUY (162 SLOC) toward D-SHORTEST-HONEST until you confirm spine
+- NOT pushing anything to GitHub
+- NOT minting any DOI
+
+## Three decisions awaiting confirm
+1. **v3 spine accepted?** 7 originals + MUSQUY + TUKUY = 9 positions
+2. **D-SHORTEST-HONEST compression pass on MUSQUY/TUKUY?** They're large because pods didn't compress; not a doctrine failure, just incomplete work. ~30 min of compression each.
+3. **Wire the 13 bracing edges?** Required to hit Maxwell M=0 on v3 spine.

docs/wiring-rationale.md

@@ -0,0 +1,87 @@
+# WIRING_RATIONALE.md — CHAKANA v3 Spine Canonical Wiring
+
+## Maxwell Rigidity Result
+
+| Parameter | Value |
+|-----------|-------|
+| Nodes (j) | 9     |
+| Edges (b) | 21    |
+| M = b − 3j + 6 | **0** |
+| Verdict | **PASS — isostatic (minimally rigid)** |
+
+---
+
+## Directed vs. Undirected — Caveat
+
+The Maxwell criterion (`M = b − 3j + 6 = 0`) is classically defined for **undirected** constraint graphs in structural mechanics (rigidity theory, Laman's theorem). Applying it to a **directed** graph is an architectural convention, not a formal proof of rigidity.
+
+**Our choice: directed edges.**
+
+AMARU is a directional cognitive pipeline; every edge carries a semantic flow direction (e.g., `KALLPA → YACHAY` means "energy primes retrieval", not the reverse). Collapsing that to undirected would erase architectural meaning.
+
+**Mitigating convention:** The 21-edge count still satisfies `M = 0` whether treated as directed or undirected (same count). The directed interpretation adds semantic precision without breaking the numeric criterion. Any future formal rigidity proof should use the undirected projection.
+
+---
+
+## Bracing Edge Justifications (13 edges)
+
+| # | Edge | Justification |
+|---|------|---------------|
+| 1 | KALLPA → HATUN | Sovereignty gate informs energy budget; the crown's continuum hash constrains how much energy the root may allocate in the next tick. |
+| 2 | NAWI → RIMAY | Toolcall results (external reads) flow back into the proposal layer; NAWI's boundary data reshapes what RIMAY can assert. |
+| 3 | NAWI → YUYAY | Toolcall results bypass proposal and pass directly to the critique gate; YUYAY can reject on boundary evidence alone. |
+| 4 | YACHAY → YUYAY | Retrieved priors (codex facts) are checked at the heart gate; YUYAY validates proposals against memory, not just logic. |
+| 5 | YACHAY → RUWAY | Codex updates that survive the gate are committed to the record via RUWAY; storage without serpent detour. |
+| 6 | KALLPA → YUYAY | Energy budget gates critique cost; YUYAY cannot run expensive multi-pass critique if KALLPA signals low energy. |
+| 7 | KALLPA → RUWAY | Commit action has an energy toll; RUWAY checks KALLPA's available budget before finalising any write. |
+| 8 | HATUN → YUYAY | The HUKLLA continuum hash flows to the heart gate so YUYAY can validate proposals against the canonical sovereign state. |
+| 9 | MUSQUY → YUYAY | If critique flags a simulation fault, YUYAY can request re-simulation; this edge carries the re-simulate signal. |
+| 10 | MUSQUY → YACHAY | Simulation consults the codex mid-flight; intermediate simulation states pull from YACHAY to avoid stale priors. |
+| 11 | MUSQUY → KALLPA | Simulation declares its energy cost upfront; KALLPA must acknowledge budget before MUSQUY proceeds. |
+| 12 | HATUN → NAWI | Sovereignty governs the external boundary; HATUN authorises which reads NAWI may open, preventing unbounded toolcall escalation. |
+| 13 | TUKUY → NAWI | Action-out is symmetric to action-in; an outbound action triggers the same boundary-crossing record in NAWI that an inbound toolcall would. |
+
+---
+
+## Edges Not Selected (and why)
+
+| Candidate | Reason not chosen |
+|-----------|------------------|
+| YUYAY ↔ RUWAY (as brace) | Already Serpent-5; would be a duplicate. |
+| TUKUY → HATUN (as brace) | Already Serpent-7; would be a duplicate — originally selected in error, replaced by HATUN→NAWI. |
+| TUKUY ↔ SENTRA-egress | SENTRA is infrastructure, not a chakra node; excluded per task specification. |
+
+---
+
+## Full Edge List (21)
+
+### Base Serpent (8)
+
+| # | Edge | Role |
+|---|------|------|
+| S1 | KALLPA → YACHAY | Energy primes retrieval |
+| S2 | YACHAY → MUSQUY | Codex feeds simulation |
+| S3 | MUSQUY → RIMAY | Simulation drives proposal |
+| S4 | RIMAY → YUYAY | Proposal enters critique gate |
+| S5 | YUYAY → RUWAY | Gate approval triggers commit |
+| S6 | RUWAY → TUKUY | Commit hands off to action-out |
+| S7 | TUKUY → HATUN | Outbound action crowned by sovereignty |
+| S8 | HATUN → KALLPA | Cycle close — sovereign hash seeds next tick |
+
+### Bracing (13)
+
+| # | Edge |
+|---|------|
+| B1 | KALLPA → HATUN |
+| B2 | NAWI → RIMAY |
+| B3 | NAWI → YUYAY |
+| B4 | YACHAY → YUYAY |
+| B5 | YACHAY → RUWAY |
+| B6 | KALLPA → YUYAY |
+| B7 | KALLPA → RUWAY |
+| B8 | HATUN → YUYAY |
+| B9 | MUSQUY → YUYAY |
+| B10 | MUSQUY → YACHAY |
+| B11 | MUSQUY → KALLPA |
+| B12 | HATUN → NAWI |
+| B13 | TUKUY → NAWI |

sidecar/README.md

@@ -0,0 +1,56 @@
+# Amaru — Andean Ouroboros brain runtime
+
+Python 7-chakra kernels behind a single FastAPI app.
+
+## Chakras (root → crown)
+
+| Order | Name | Module |
+| ----- | ---- | ------ |
+| 1 | root | `amaru.chakras.root` |
+| 2 | sacral | `amaru.chakras.sacral` |
+| 3 | solar | `amaru.chakras.solar` |
+| 4 | heart | `amaru.chakras.heart` |
+| 5 | throat | `amaru.chakras.throat` |
+| 6 | third_eye | `amaru.chakras.third_eye` |
+| 7 | crown | `amaru.chakras.crown` |
+
+Each chakra has:
+
+- `kernel.py` — the executable kernel (port of upstream Amaru; when the upstream
+  Python is not vendored locally, the kernel raises
+  `NotImplementedError("upstream kernel not vendored")` which the runtime
+  surfaces verbatim — never silently faked).
+- `LEADER.md` — leader doctrine and the canonical minimization-proof hash.
+- `proof.json` — the minimization-proof receipt (proof_id + sha256).
+- `result.json` — the canonical last result.
+- `rejected.md` — rejected alternatives.
+
+## Surface
+
+- `POST /chakra/{name}/evaluate` — run that chakra's kernel against an input
+  envelope. Returns chakra output + minimization-proof receipt id.
+- `GET  /chakra/{name}/leader` — `LEADER.md` content + the canonical proof hash.
+- `POST /scheduler/tick` — run `amaru_scheduler` one step over the configured
+  `chakana_wiring`.
+- `GET  /healthz` — liveness.
+- `GET  /tripwires` — `huklla-10` tripwire status.
+
+Every chakra evaluation publishes a receipt to topic `amaru.chakra` on the
+yawar-bus (Prism Bus HTTP surface). Every scheduler tick publishes to
+`amaru.scheduler`. Both are replayable from the bus history endpoint.
+
+## Running locally
+
+The api-server artifact exposes a service entry `amaru` (autoStart=false).
+Start it from the workflow panel when you want the runtime up.
+
+```bash
+PORT=6810 pnpm run amaru:dev      # workspace shortcut, or:
+PORT=6810 python -m uvicorn amaru.app:app --host 0.0.0.0 --port 6810
+```
+
+## Doctrine note
+
+This service is `doctrine-scanner-exempt` per task #5176. The upstream chakra
+kernels live in the published Amaru bundle; this runtime is a thin local
+process + receipt chain that wraps them.

sidecar/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "amaru"
+version = "0.1.0"
+description = "Amaru — Andean Ouroboros brain runtime. 7-chakra kernels behind a single FastAPI surface."
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.111.0",
+    "uvicorn[standard]>=0.30.0",
+    "pydantic>=2.7.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.4.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/amaru"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

sidecar/scripts/bootstrap_venv.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+# Self-heal the amaru venv. Runs at every workflow start; no-ops if the venv
+# is already present and importable. Idempotent.
+#
+# Important: we deliberately verify by file presence inside the venv's own
+# site-packages, NOT by `python -c "import …"`. A bare import can succeed
+# against PEP 370 user-site or system packages even when the venv is empty,
+# which produced silent under-installs in the past.
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+VENV=".venv"
+PYBIN="$VENV/bin/python"
+SITE="$VENV/lib/python3.11/site-packages"
+
+required_paths=(
+  "$PYBIN"
+  "$SITE/fastapi"
+  "$SITE/uvicorn"
+  "$SITE/typing_extensions.py"
+  "$SITE/anyio"
+  "$SITE/pydantic"
+)
+
+needs_bootstrap=0
+for p in "${required_paths[@]}"; do
+  if [[ ! -e "$p" ]]; then
+    needs_bootstrap=1
+    break
+  fi
+done
+
+# Modern pip (PEP 660) editable installs do NOT create amaru.egg-link.
+# They create _editable_impl_amaru.pth + an amaru-*.dist-info directory.
+# Accept either layout; rebuild only if neither marker is present.
+if [[ "$needs_bootstrap" -eq 0 ]]; then
+  if [[ ! -e "$SITE/_editable_impl_amaru.pth" ]] \
+     && [[ -z "$(compgen -G "$SITE/amaru-*.dist-info" || true)" ]] \
+     && [[ ! -e "$SITE/amaru.egg-link" ]]; then
+    needs_bootstrap=1
+  fi
+fi
+
+if [[ "$needs_bootstrap" -eq 1 ]]; then
+  echo "[amaru bootstrap] (re)creating .venv"
+  rm -rf "$VENV"
+  python3 -m venv "$VENV"
+  # --break-system-packages is required because the Nix-provided python is
+  # marked PEP 668 externally-managed; the flag is harmless inside our own
+  # venv (we are not modifying /nix/store).
+  # --ignore-installed forces pip to write into the venv even when a
+  # package is already present in the (read-only) Nix store. Without it,
+  # pip will try to upgrade-in-place inside /nix/store and fail with EACCES.
+  env PIP_USER=0 "$VENV/bin/pip" install --no-user --quiet --break-system-packages --ignore-installed \
+    -e ".[dev]" \
+    "typing_extensions>=4.0" >/dev/null
+  echo "[amaru bootstrap] ready"
+else
+  echo "[amaru bootstrap] .venv healthy, skipping"
+fi

sidecar/scripts/pin_proofs.py

@@ -0,0 +1,46 @@
+"""
+pin_proofs.py — recompute every chakra's proof.json sha256 over the
+canonical kernel.py source bytes. Run after editing a kernel to keep
+provenance honest.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+CHAKRA_ROOT = Path(__file__).resolve().parents[1] / "src" / "amaru" / "chakras"
+
+KERNEL_SUMMARY = {
+    "root": ("amaru.root.v1", "mean of (grounded + integrity) / 2, clamped to [0,1]"),
+    "sacral": ("amaru.sacral.v1", "convex blend 0.6*fluency + 0.4*novelty, clamped to [0,1]"),
+    "solar": ("amaru.solar.v1", "intent * agency - friction, clamped to [0,1]"),
+    "heart": ("amaru.heart.v1", "care - harm clamped to [0,1]"),
+    "throat": ("amaru.throat.v1", "geometric mean sqrt(clarity*truth), clamped to [0,1]"),
+    "third_eye": ("amaru.third_eye.v1", "pattern_strength * (1 - uncertainty), clamped to [0,1]"),
+    "crown": ("amaru.crown.v1", "arithmetic mean of upstream scalars, clamped to [0,1]"),
+}
+
+
+def main() -> int:
+    for chakra, (proof_id, summary) in KERNEL_SUMMARY.items():
+        kernel_path = CHAKRA_ROOT / chakra / "kernel.py"
+        proof_path = CHAKRA_ROOT / chakra / "proof.json"
+        if not kernel_path.exists():
+            raise SystemExit(f"missing kernel: {kernel_path}")
+        digest = hashlib.sha256(kernel_path.read_bytes()).hexdigest()
+        proof = {
+            "proof_id": proof_id,
+            "sha256": digest,
+            "kind": "kernel-source",
+            "summary": summary,
+            "notes": "sha256 computed over the canonical kernel.py source bytes; re-pin via services/amaru/scripts/pin_proofs.py after edits.",
+        }
+        proof_path.write_text(json.dumps(proof, indent=2) + "\n")
+        print(f"{chakra}: {proof_id} -> {digest}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sidecar/scripts/pin_results.py

@@ -0,0 +1,44 @@
+"""
+pin_results.py — runs each chakra kernel against a canonical envelope
+and writes the verbatim (input, output) pair into result.json so the
+shipped artifact reflects real runtime behavior.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+CANONICAL = {
+    "root": {"signals": {"grounded": 0.9, "integrity": 0.9}},
+    "sacral": {"signals": {"novelty": 0.5, "fluency": 0.8}},
+    "solar": {"signals": {"intent": 0.8, "agency": 0.9, "friction": 0.1}},
+    "heart": {"signals": {"care": 0.9, "harm": 0.1}},
+    "throat": {"signals": {"clarity": 0.81, "truth": 0.64}},
+    "third_eye": {"signals": {"pattern_strength": 0.7, "uncertainty": 0.2}},
+    "crown": {"upstream": {"stability": 0.9, "flow": 0.68, "will": 0.62, "coherence": 0.8, "fidelity": 0.72, "insight": 0.56}},
+}
+
+
+def main() -> int:
+    for name, envelope in CANONICAL.items():
+        kernel = importlib.import_module(f"amaru.chakras.{name}.kernel")
+        output = kernel.evaluate(envelope)
+        path = ROOT / "src" / "amaru" / "chakras" / name / "result.json"
+        path.write_text(json.dumps({
+            "canonical_input": envelope,
+            "canonical_output": output,
+            "stubbed": False,
+            "proof_id": f"amaru.{name}.v1",
+        }, indent=2, sort_keys=True) + "\n")
+        print(f"{name}: {output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sidecar/scripts/serve_dualstack.py

@@ -0,0 +1,14 @@
+import os
+import socket
+import uvicorn
+
+PORT = int(os.environ.get("PORT", "6810"))
+
+sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+sock.bind(("::", PORT))
+sock.listen(128)
+sock.setblocking(False)
+
+uvicorn.run("amaru.app:app", fd=sock.fileno())

sidecar/scripts/vendor_anatomy.py

@@ -0,0 +1,128 @@
+"""
+vendor_anatomy.py — deterministic local renderer for the 7-chakra
+anatomy bundle that ships under `artifacts/a11oy/public/anatomy/`.
+
+Renders 14 byte-stable binaries (7 chakras × {pdf, png}) and pins
+VENDOR.json::upstream_sha to the documented bundle hash:
+    sha256( sorted (filename || NUL || bytes || NUL) ).
+
+Determinism is via reportlab `Canvas(invariant=True)` plus PIL default
+`Image.save(..., "PNG")` so re-runs do not change the pinned hash.
+
+This is a sanctioned local rendering of the anatomy bundle for the
+Amaru runtime. When the upstream Ouroboros publication ships a new
+canonical figure set, drop those bytes in here and re-pin with
+`--repin-only`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+from reportlab.lib.pagesizes import LETTER
+from reportlab.lib.units import inch
+from reportlab.pdfgen import canvas
+
+ROOT = Path(__file__).resolve().parents[3] / "artifacts" / "a11oy" / "public" / "anatomy"
+
+CHAKRAS = [
+    ("root", "Root — muladhara — substrate grounding", (139, 90, 43)),
+    ("sacral", "Sacral — svadhisthana — generative flow", (220, 130, 60)),
+    ("solar", "Solar — manipura — will / decisive action", (235, 200, 70)),
+    ("heart", "Heart — anahata — coherence / harm-avoidance", (90, 170, 110)),
+    ("throat", "Throat — vishuddha — expressive fidelity", (70, 140, 200)),
+    ("third_eye", "Third eye — ajna — predictive insight", (90, 80, 190)),
+    ("crown", "Crown — sahasrara — closure / ouroboros", (170, 110, 200)),
+]
+
+WIDTH_PX, HEIGHT_PX = 1200, 800
+
+
+def render_png(path: Path, chakra: str, title: str, color: tuple[int, int, int]) -> None:
+    img = Image.new("RGB", (WIDTH_PX, HEIGHT_PX), (16, 16, 18))
+    d = ImageDraw.Draw(img)
+    cx, cy = WIDTH_PX // 2, HEIGHT_PX // 2
+    for i, r in enumerate(range(260, 60, -20)):
+        shade = tuple(min(255, c + i * 6) for c in color)
+        d.ellipse((cx - r, cy - r, cx + r, cy + r), outline=shade, width=2)
+    font = ImageFont.load_default()
+    d.text((40, 40), "OUROBOROS ANATOMY", fill=(201, 183, 135), font=font)
+    d.text((40, 70), title, fill=(230, 230, 230), font=font)
+    d.text((40, HEIGHT_PX - 60), f"chakra: {chakra}", fill=(140, 140, 140), font=font)
+    img.save(path, format="PNG", optimize=False, pnginfo=None)
+
+
+def render_pdf(path: Path, chakra: str, title: str) -> None:
+    c = canvas.Canvas(str(path), pagesize=LETTER, invariant=True)
+    width, height = LETTER
+    c.setFillColorRGB(0.79, 0.72, 0.53)
+    c.setFont("Helvetica-Bold", 14)
+    c.drawString(0.75 * inch, height - 0.85 * inch, "OUROBOROS ANATOMY")
+    c.setFillColorRGB(0.9, 0.9, 0.9)
+    c.setFont("Helvetica", 18)
+    c.drawString(0.75 * inch, height - 1.25 * inch, title)
+    c.setFillColorRGB(0.55, 0.55, 0.55)
+    c.setFont("Helvetica", 10)
+    c.drawString(0.75 * inch, height - 1.55 * inch, f"chakra: {chakra}")
+    c.setStrokeColorRGB(0.45, 0.40, 0.30)
+    c.setLineWidth(1.0)
+    cx, cy = width / 2, height / 2 - 0.5 * inch
+    for r in range(40, 200, 18):
+        c.circle(cx, cy, r, stroke=1, fill=0)
+    c.showPage()
+    c.save()
+
+
+def compute_bundle_sha(dir_: Path, expected_files: list[str]) -> str:
+    h = hashlib.sha256()
+    for fname in sorted(expected_files):
+        p = dir_ / fname
+        if not p.exists():
+            raise SystemExit(f"missing expected file: {fname}")
+        h.update(fname.encode("utf-8"))
+        h.update(b"\x00")
+        h.update(p.read_bytes())
+        h.update(b"\x00")
+    return h.hexdigest()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--repin-only", action="store_true")
+    args = parser.parse_args()
+
+    ROOT.mkdir(parents=True, exist_ok=True)
+    expected: list[str] = []
+    for chakra, title, color in CHAKRAS:
+        expected.extend([f"{chakra}.pdf", f"{chakra}.png"])
+        if not args.repin_only:
+            render_pdf(ROOT / f"{chakra}.pdf", chakra, title)
+            render_png(ROOT / f"{chakra}.png", chakra, title, color)
+
+    bundle_sha = compute_bundle_sha(ROOT, expected)
+    vendor = {
+        "source": "Ouroboros thesis — 7-chakra anatomy bundle (locally vendored)",
+        "upstream_sha": bundle_sha,
+        "vendored_at": "2026-05-18T00:00:00Z",
+        "vendored_by": "services/amaru/scripts/vendor_anatomy.py",
+        "policy": "read-only mirror. Re-pin via `python vendor_anatomy.py --repin-only` after replacing the binaries.",
+        "bundle_kind": "vendored",
+        "expected_files": expected,
+        "drift_detection": {
+            "algorithm": "sha256 over sorted (filename || NUL || bytes || NUL) for every entry in expected_files",
+            "expected_hash": bundle_sha,
+            "note": "The A11oy /anatomy viewer recomputes this hash in-browser over the served files on every load and compares it to upstream_sha. Drift surfaces a banner.",
+        },
+    }
+    (ROOT / "VENDOR.json").write_text(json.dumps(vendor, indent=2) + "\n")
+    print(f"pinned bundle sha256={bundle_sha}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sidecar/src/amaru/__init__.py

@@ -0,0 +1,13 @@
+"""Amaru — Andean Ouroboros brain runtime."""
+
+__version__ = "0.1.0"
+
+CHAKRA_ORDER: tuple[str, ...] = (
+    "root",
+    "sacral",
+    "solar",
+    "heart",
+    "throat",
+    "third_eye",
+    "crown",
+)

sidecar/src/amaru/amaru_scheduler.py

@@ -0,0 +1,119 @@
+"""
+amaru_scheduler — one-step scheduler over the chakana wiring.
+
+A tick walks the canonical root→crown ascent (then the ouroboros closure
+back to root), evaluating each chakra against the rolling envelope. Stubbed
+kernels are surfaced as `{stubbed: true, error: ...}` — never silently
+substituted.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from . import CHAKRA_ORDER
+from .chakana_wiring import wiring_snapshot
+from .chakras import get_chakra
+from .receipts import ReceiptChain
+
+
+@dataclass
+class ChakraStep:
+    chakra: str
+    output: dict[str, Any] | None
+    error: str | None
+    stubbed: bool
+    receipt_seq: int
+
+
+@dataclass
+class TickResult:
+    tick_id: int
+    steps: list[ChakraStep] = field(default_factory=list)
+    closure: float | None = None
+    handoff: dict[str, Any] | None = None
+
+
+class AmaruScheduler:
+    def __init__(self, chain: ReceiptChain) -> None:
+        self._chain = chain
+        self._tick_count = 0
+        self._stub_surfaces: set[str] = set()
+
+    @property
+    def tick_count(self) -> int:
+        return self._tick_count
+
+    @property
+    def stubbed_chakras(self) -> list[str]:
+        return sorted(self._stub_surfaces)
+
+    def tick(self, envelope: dict[str, Any] | None = None) -> TickResult:
+        self._tick_count += 1
+        env: dict[str, Any] = dict(envelope or {})
+        env.setdefault("signals", {})
+        upstream: dict[str, Any] = {}
+
+        result = TickResult(tick_id=self._tick_count)
+
+        for name in CHAKRA_ORDER:
+            entry = get_chakra(name)
+            if name == "crown":
+                step_env = dict(env)
+                step_env["upstream"] = upstream
+            else:
+                step_env = env
+            try:
+                output = entry.evaluate(step_env)
+                error: str | None = None
+            except NotImplementedError as exc:
+                output = None
+                error = str(exc)
+                self._stub_surfaces.add(name)
+            except Exception as exc:  # noqa: BLE001
+                output = None
+                error = f"{type(exc).__name__}: {exc}"
+
+            receipt = self._chain.append(
+                endpoint=f"/scheduler/tick/{name}",
+                method="POST",
+                params={"envelope": step_env},
+                result={"output": output, "error": error},
+                metadata={
+                    "chakra": name,
+                    "tick": self._tick_count,
+                    "stubbed": entry.stubbed,
+                    "proof_id": entry.proof.get("proof_id"),
+                },
+            )
+
+            if output and isinstance(output, dict):
+                for k, v in output.items():
+                    if isinstance(v, (int, float)) and k not in {"chakra", "n_upstream_scalars"}:
+                        upstream[k] = v
+
+            result.steps.append(
+                ChakraStep(
+                    chakra=name,
+                    output=output,
+                    error=error,
+                    stubbed=entry.stubbed,
+                    receipt_seq=receipt.seq,
+                )
+            )
+
+            if name == "crown" and output:
+                closure = output.get("closure")
+                handoff = output.get("handoff")
+                if isinstance(closure, (int, float)):
+                    result.closure = float(closure)
+                if isinstance(handoff, dict):
+                    result.handoff = handoff
+
+        return result
+
+
+def snapshot() -> dict[str, Any]:
+    """Return the static wiring snapshot (for `/scheduler/wiring`)."""
+    return wiring_snapshot()

sidecar/src/amaru/app.py

@@ -0,0 +1,435 @@
+"""Amaru — FastAPI app exposing the 7-chakra runtime."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import Any
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from . import CHAKRA_ORDER, __version__
+from .chakana_wiring import wiring_snapshot
+from .chakras import CHAKRA_REGISTRY, get_chakra
+from .amaru_scheduler import AmaruScheduler
+from .huklla import evaluate_all
+from . import overwatch as _overwatch
+from .receipts import ReceiptChain
+from .yawar_bus import get_bus
+
+app = FastAPI(
+    title="Amaru — Andean Ouroboros brain runtime",
+    version=__version__,
+    description="7-chakra kernels behind one FastAPI surface (task #5176).",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+_chain = ReceiptChain(operator_id="amaru-runtime")
+_scheduler = AmaruScheduler(_chain)
+_bus = get_bus()
+
+# Runtime counters surfaced via tripwires / metrics
+_state: dict[str, Any] = {
+    "bus_publishes": 0,
+    "bus_publish_failures": 0,
+    "oversized_envelopes": 0,
+    "last_evaluation": {name: None for name in CHAKRA_ORDER},
+}
+
+ENVELOPE_SOFT_LIMIT_BYTES = 65_536
+
+# In-process fan-out for SSE subscribers. Each subscriber gets its own bounded
+# queue; slow consumers drop oldest events rather than blocking publishers.
+_sse_subscribers: list[asyncio.Queue[dict[str, Any]]] = []
+_SSE_QUEUE_MAX = 64
+
+
+def _sse_broadcast(event: dict[str, Any]) -> None:
+    for q in list(_sse_subscribers):
+        try:
+            if q.full():
+                try:
+                    q.get_nowait()
+                except asyncio.QueueEmpty:
+                    pass
+            q.put_nowait(event)
+        except Exception:
+            pass
+
+
+class EvaluateRequest(BaseModel):
+    envelope: dict[str, Any] = Field(default_factory=dict)
+
+
+class SchedulerTickRequest(BaseModel):
+    envelope: dict[str, Any] | None = None
+
+
+def _publish_async(coro: Any) -> None:
+    """Fire-and-forget bus publish that never blocks the request."""
+    try:
+        loop = asyncio.get_running_loop()
+        loop.create_task(coro)
+    except RuntimeError:
+        # No loop yet — drop. Bus publish is best-effort.
+        pass
+
+
+async def _publish_chakra(name: str, evaluation: dict[str, Any]) -> None:
+    result = await _bus.publish(
+        type_="amaru.chakra",
+        source_id=f"amaru:{name}",
+        payload=evaluation,
+    )
+    _state["bus_publishes"] += 1
+    if not result.get("ok"):
+        _state["bus_publish_failures"] += 1
+    _sse_broadcast({"type": "amaru.chakra", "source_id": f"amaru:{name}", "payload": evaluation})
+
+
+async def _publish_tick(payload: dict[str, Any]) -> None:
+    result = await _bus.publish(
+        type_="amaru.scheduler",
+        source_id="amaru:scheduler",
+        payload=payload,
+    )
+    _state["bus_publishes"] += 1
+    if not result.get("ok"):
+        _state["bus_publish_failures"] += 1
+    _sse_broadcast({"type": "amaru.scheduler", "source_id": "amaru:scheduler", "payload": payload})
+
+
+@app.get("/healthz")
+def healthz() -> dict[str, Any]:
+    return {
+        "ok": True,
+        "service": "amaru",
+        "version": __version__,
+        "chakras": list(CHAKRA_ORDER),
+        "stubbed": [name for name, e in CHAKRA_REGISTRY.items() if e.stubbed],
+        "scheduler_ticks": _scheduler.tick_count,
+        "receipts": _chain.length(),
+    }
+
+
+@app.get("/health")
+def health() -> dict[str, Any]:
+    """Alias of /healthz for clients that probe the conventional path."""
+    return healthz()
+
+
+@app.get("/")
+def root() -> dict[str, Any]:
+    """Service identity card — points discoverers at /docs and /healthz."""
+    return {
+        "service": "amaru",
+        "version": __version__,
+        "docs": "/docs",
+        "openapi": "/openapi.json",
+        "health": "/healthz",
+        "endpoints": [
+            "/healthz",
+            "/overwatch/snapshot",
+            "/chakra/{name}/leader",
+            "/chakra/{name}/evaluate",
+            "/scheduler/tick",
+            "/scheduler/wiring",
+            "/state",
+            "/receipts",
+            "/events",
+            "/tripwires",
+        ],
+    }
+
+
+@app.get("/overwatch/snapshot")
+def overwatch_snapshot() -> dict[str, Any]:
+    """R0513 — read-only OVERWATCH panel (6 invariants).
+
+    Doctrine: R0513 watches; halt authority belongs to HUKLLA. This endpoint
+    never mutates state. It computes the panel against the current receipt
+    chain and chakana wiring."""
+    receipts = [r.to_dict() for r in _chain.all()]
+    snap = _overwatch.evaluate_panel(
+        receipts=receipts,
+        wiring=wiring_snapshot(),
+        baseline_axes=None,
+        observed_axes=None,
+        margins=None,
+        in_flight=0,
+        regated=0,
+    )
+    return snap.to_dict()
+
+
+@app.get("/chakra/{name}/leader")
+def get_leader(name: str) -> dict[str, Any]:
+    try:
+        entry = get_chakra(name)
+    except KeyError:
+        raise HTTPException(status_code=404, detail=f"unknown chakra: {name}")
+    return {
+        "chakra": entry.name,
+        "leader_md": entry.leader_md,
+        "proof_id": entry.proof.get("proof_id"),
+        "proof_sha256": entry.proof.get("sha256"),
+        "proof_kind": entry.proof.get("kind"),
+        "stubbed": entry.stubbed,
+        "rejected_md": entry.rejected_md,
+    }
+
+
+@app.post("/chakra/{name}/evaluate")
+async def evaluate_chakra(name: str, body: EvaluateRequest) -> dict[str, Any]:
+    try:
+        entry = get_chakra(name)
+    except KeyError:
+        raise HTTPException(status_code=404, detail=f"unknown chakra: {name}")
+
+    envelope = body.envelope or {}
+    # Soft envelope size guard (tripwire huklla-9).
+    try:
+        size = len(repr(envelope).encode("utf-8"))
+        if size > ENVELOPE_SOFT_LIMIT_BYTES:
+            _state["oversized_envelopes"] += 1
+    except Exception:
+        pass
+
+    try:
+        output = entry.evaluate(envelope)
+        error: str | None = None
+    except NotImplementedError as exc:
+        output = None
+        error = str(exc)
+    except Exception as exc:  # noqa: BLE001
+        output = None
+        error = f"{type(exc).__name__}: {exc}"
+
+    receipt = _chain.append(
+        endpoint=f"/chakra/{name}/evaluate",
+        method="POST",
+        params={"envelope": envelope},
+        result={"output": output, "error": error},
+        metadata={
+            "chakra": name,
+            "stubbed": entry.stubbed,
+            "proof_id": entry.proof.get("proof_id"),
+        },
+    )
+
+    evaluation = {
+        "chakra": name,
+        "proof_id": entry.proof.get("proof_id"),
+        "output": output,
+        "error": error,
+        "stubbed": entry.stubbed,
+        "receipt": receipt.to_dict(),
+    }
+    _state["last_evaluation"][name] = evaluation
+
+    _publish_async(_publish_chakra(name, evaluation))
+
+    if error and not entry.stubbed:
+        # Real runtime failure — return 500. Stub kernels return 200 with the
+        # error so the Brain panel can render "stubbed, surfaced loudly".
+        raise HTTPException(status_code=500, detail=evaluation)
+
+    return evaluation
+
+
+@app.post("/scheduler/tick")
+async def scheduler_tick(body: SchedulerTickRequest) -> dict[str, Any]:
+    result = _scheduler.tick(body.envelope)
+    step_seqs = [s.receipt_seq for s in result.steps]
+    # Single canonical tick-level receipt that summarises the whole tick.
+    # Downstream consumers of `amaru.scheduler` can pin to this id/hash
+    # for replay/audit instead of stitching together per-step seqs.
+    tick_receipt = _chain.append(
+        endpoint="/scheduler/tick",
+        method="POST",
+        params={"envelope": body.envelope or {}},
+        result={
+            "tick_id": result.tick_id,
+            "closure": result.closure,
+            "handoff": result.handoff,
+            "step_receipt_seqs": step_seqs,
+        },
+        metadata={
+            "kind": "scheduler_tick",
+            "tick": result.tick_id,
+            "step_count": len(result.steps),
+            "stubbed_count": sum(1 for s in result.steps if s.stubbed),
+        },
+    )
+    payload = {
+        "tick_id": result.tick_id,
+        "tick_receipt": {
+            "seq": tick_receipt.seq,
+            "hash": tick_receipt.self_hash,
+            "prevHash": tick_receipt.prev_hash,
+        },
+        "steps": [
+            {
+                "chakra": s.chakra,
+                "output": s.output,
+                "error": s.error,
+                "stubbed": s.stubbed,
+                "receipt_seq": s.receipt_seq,
+            }
+            for s in result.steps
+        ],
+        "closure": result.closure,
+        "handoff": result.handoff,
+    }
+
+    # Mirror per-chakra last-evaluation snapshots so the Brain panel can
+    # poll a single source after a scheduler tick, AND publish each step
+    # to `amaru.chakra` so the bus stream and SSE clients see every
+    # kernel evaluation (replay fidelity: one tick = 7 amaru.chakra
+    # events + 1 amaru.scheduler event).
+    for s in result.steps:
+        entry = CHAKRA_REGISTRY[s.chakra]
+        step_evaluation = {
+            "chakra": s.chakra,
+            "proof_id": entry.proof.get("proof_id"),
+            "output": s.output,
+            "error": s.error,
+            "stubbed": s.stubbed,
+            "receipt": {"seq": s.receipt_seq},
+            "via": "scheduler",
+            "tick_id": result.tick_id,
+        }
+        _state["last_evaluation"][s.chakra] = step_evaluation
+        _publish_async(_publish_chakra(s.chakra, step_evaluation))
+
+    _publish_async(_publish_tick(payload))
+
+    return payload
+
+
+@app.get("/scheduler/wiring")
+def scheduler_wiring() -> dict[str, Any]:
+    return wiring_snapshot()
+
+
+@app.get("/state")
+def runtime_state() -> dict[str, Any]:
+    return {
+        "chakras": list(CHAKRA_ORDER),
+        "last_evaluation": _state["last_evaluation"],
+        "scheduler_ticks": _scheduler.tick_count,
+        "receipts": _chain.length(),
+        "bus": {
+            "publishes": _state["bus_publishes"],
+            "failures": _state["bus_publish_failures"],
+        },
+    }
+
+
+@app.get("/receipts")
+def receipts(limit: int = 50) -> dict[str, Any]:
+    all_receipts = _chain.all()
+    tail = all_receipts[-max(1, min(limit, 500)) :]
+    return {
+        "total": len(all_receipts),
+        "head_seq": all_receipts[-1].seq if all_receipts else 0,
+        "items": [r.to_dict() for r in tail],
+    }
+
+
+@app.get("/events")
+async def events() -> StreamingResponse:
+    """SSE stream of `amaru.chakra` and `amaru.scheduler` events.
+
+    Subscribers receive a `hello` event on connect and then JSON-encoded
+    bus envelopes as they are published. Topic names match the Prism Bus
+    publish contract exactly (`amaru.chakra`, `amaru.scheduler`).
+    """
+    queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=_SSE_QUEUE_MAX)
+    _sse_subscribers.append(queue)
+
+    async def gen() -> Any:
+        try:
+            hello = {
+                "type": "hello",
+                "payload": {
+                    "chakras": list(CHAKRA_ORDER),
+                    "topics": ["amaru.chakra", "amaru.scheduler"],
+                },
+            }
+            yield f"event: {hello['type']}\ndata: {json.dumps(hello)}\n\n"
+            while True:
+                try:
+                    evt = await asyncio.wait_for(queue.get(), timeout=15.0)
+                    yield f"event: {evt['type']}\ndata: {json.dumps(evt)}\n\n"
+                except asyncio.TimeoutError:
+                    # Heartbeat keeps proxies from closing the connection.
+                    yield ": keepalive\n\n"
+        finally:
+            if queue in _sse_subscribers:
+                _sse_subscribers.remove(queue)
+
+    return StreamingResponse(
+        gen(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache, no-transform",
+            "X-Accel-Buffering": "no",
+            "Connection": "keep-alive",
+        },
+    )
+
+
+@app.get("/tripwires")
+def tripwires() -> dict[str, Any]:
+    snap = {
+        "registered_chakras": list(CHAKRA_REGISTRY.keys()),
+        "chain_breaks": 0,
+        "chakras_missing_proof": [
+            n for n, e in CHAKRA_REGISTRY.items() if not e.proof.get("proof_id")
+        ],
+        "stubbed_chakras": [n for n, e in CHAKRA_REGISTRY.items() if e.stubbed],
+        "scheduler_ticks": _scheduler.tick_count,
+        "unexpected_cycles": 0,
+        "bus_publishes": _state["bus_publishes"],
+        "bus_publish_failures": _state["bus_publish_failures"],
+        "chakras_missing_leader": [
+            n for n, e in CHAKRA_REGISTRY.items() if not e.leader_md.strip()
+        ],
+        "oversized_envelopes": _state["oversized_envelopes"],
+        "declared_order": list(CHAKRA_ORDER),
+    }
+    results = evaluate_all(snap)
+    return {
+        "summary": {
+            "pass": sum(1 for r in results if r.status == "pass"),
+            "warn": sum(1 for r in results if r.status == "warn"),
+            "trip": sum(1 for r in results if r.status == "trip"),
+            "total": len(results),
+        },
+        "tripwires": [
+            {"id": r.id, "title": r.title, "status": r.status, "detail": r.detail}
+            for r in results
+        ],
+    }
+
+
+def main() -> None:
+    import uvicorn
+
+    port = int(os.environ.get("PORT", "6810"))
+    uvicorn.run("amaru.app:app", host="0.0.0.0", port=port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

sidecar/src/amaru/chakana_wiring.py

@@ -0,0 +1,51 @@
+"""
+chakana_wiring — fixed topology of the 7-chakra Andean cross.
+
+The chakana (Andean cross) is a four-step staircase whose vertices we map
+onto the 7 chakras. Read top→bottom the topology is an ouroboros: crown
+feeds back into root, closing the cycle.
+
+The wiring is intentionally static — there is no graph DB here, no runtime
+mutation. If a kernel needs a different shape it ships as a new wiring file.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import CHAKRA_ORDER
+
+
+@dataclass(frozen=True)
+class Edge:
+    src: str
+    dst: str
+    role: str  # e.g. "ascend" (root→crown direction) or "ouroboros" (crown→root)
+
+
+# Sequential ascent root → sacral → solar → heart → throat → third_eye → crown.
+ASCENT_EDGES: tuple[Edge, ...] = tuple(
+    Edge(src=CHAKRA_ORDER[i], dst=CHAKRA_ORDER[i + 1], role="ascend")
+    for i in range(len(CHAKRA_ORDER) - 1)
+)
+
+# Ouroboros closure: crown loops back to root.
+OUROBOROS_EDGE: Edge = Edge(src="crown", dst="root", role="ouroboros")
+
+ALL_EDGES: tuple[Edge, ...] = ASCENT_EDGES + (OUROBOROS_EDGE,)
+
+
+def downstream_of(name: str) -> list[Edge]:
+    return [e for e in ALL_EDGES if e.src == name]
+
+
+def upstream_of(name: str) -> list[Edge]:
+    return [e for e in ALL_EDGES if e.dst == name]
+
+
+def wiring_snapshot() -> dict:
+    return {
+        "chakras": list(CHAKRA_ORDER),
+        "edges": [{"src": e.src, "dst": e.dst, "role": e.role} for e in ALL_EDGES],
+        "shape": "andean-cross-ouroboros",
+    }

sidecar/src/amaru/chakras/__init__.py

@@ -0,0 +1,73 @@
+"""
+Amaru chakra kernels — one subpackage per chakra (root..crown).
+
+The registry below is loaded once at module import. Each entry resolves a
+chakra name to its kernel callable, LEADER.md text, and proof receipt.
+
+If the upstream kernel for a chakra is not vendored locally, `kernel.evaluate`
+raises `NotImplementedError("upstream kernel not vendored")`. The runtime
+surfaces that loudly — it is never silently substituted with a fake result.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+from .. import CHAKRA_ORDER
+
+_HERE = Path(__file__).resolve().parent
+
+
+@dataclass(frozen=True)
+class ChakraEntry:
+    name: str
+    evaluate: Callable[[Mapping[str, Any]], dict[str, Any]]
+    leader_md: str
+    proof: dict[str, Any]
+    rejected_md: str
+    stubbed: bool
+
+
+def _load_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8") if path.exists() else ""
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def _build_registry() -> dict[str, ChakraEntry]:
+    registry: dict[str, ChakraEntry] = {}
+    for name in CHAKRA_ORDER:
+        sub = _HERE / name
+        module = importlib.import_module(f"amaru.chakras.{name}.kernel")
+        evaluate = getattr(module, "evaluate")
+        stubbed = bool(getattr(module, "STUBBED", False))
+        registry[name] = ChakraEntry(
+            name=name,
+            evaluate=evaluate,
+            leader_md=_load_text(sub / "LEADER.md"),
+            proof=_load_json(sub / "proof.json"),
+            rejected_md=_load_text(sub / "rejected.md"),
+            stubbed=stubbed,
+        )
+    return registry
+
+
+CHAKRA_REGISTRY: dict[str, ChakraEntry] = _build_registry()
+
+
+def get_chakra(name: str) -> ChakraEntry:
+    entry = CHAKRA_REGISTRY.get(name)
+    if entry is None:
+        raise KeyError(f"unknown chakra: {name!r}")
+    return entry

sidecar/src/amaru/chakras/_stub_kernel.py

@@ -0,0 +1,17 @@
+"""Helper to declare a chakra whose upstream kernel is not vendored locally."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+def make_stub(name: str):
+    STUBBED = True
+
+    def evaluate(envelope: Mapping[str, Any]) -> dict[str, Any]:
+        raise NotImplementedError(
+            f"upstream kernel not vendored (chakra={name!r}). "
+            "Vendor the upstream Amaru bundle to enable real evaluation."
+        )
+
+    return STUBBED, evaluate

sidecar/src/amaru/chakras/crown/LEADER.md

@@ -0,0 +1,17 @@
+# LEADER — crown chakra (sahasrara)
+
+**Role:** closure / ouroboros.
+
+**Status:** LIVE. `kernel.evaluate` (proof `amaru.crown.v1`) aggregates
+upstream scalar readings into `closure = clamp(mean(upstream
+scalars), 0, 1)` and emits `verdict ∈ {"close", "spin"}` (threshold
+0.5) plus a fixed `handoff = { to: "root", via: "ouroboros" }` so the
+scheduler closes the loop deterministically.
+
+**Minimization proof:** `proof.json` — `proof_id=amaru.crown.v1`,
+`sha256` is the canonical hash of `kernel.py` source bytes (re-pin via
+`pin_proofs.py`).
+
+**Canonical output shape:** `{ chakra: "crown", closure: ∈[0,1],
+verdict, n_upstream_scalars, handoff: { to: "root", via: "ouroboros" }
+}` — see `result.json`.