Install PRISM

Four channels, one result: the harness that disciplines your agent and cuts its token bill — installed where you want it. The recommended path: download the installer below, review it, then run it with Bash. A minisign-pinned install against the Sept 2026 GitSpawn-class supply-chain threat is planned but not available yet.

prism_dir=$(mktemp -d) && curl -fsSL https://git.sovereign-society.org/prism/prism-harness/raw/branch/main/install.sh -o "$prism_dir/install.sh"

Review install.sh before execution (less "$prism_dir/install.sh"), then run it from your project, in the same shell: bash "$prism_dir/install.sh".

1. install.sh — the Bash meta-installer

Pulls the sovereign repos under git.sovereign-society.org/prism, installs the global harness (the layer that shapes every agent in all your projects), then offers to scaffold one working repo with the doctrine. Repo-aware by default: inside a git repo it asks to scaffold that repo (default yes); with no repo it offers git init — default no, so non-developers can just take the global assistant layer.

Download it into a fresh temporary directory, so it cannot overwrite an install.sh in your project:

prism_dir=$(mktemp -d) && curl -fsSL https://git.sovereign-society.org/prism/prism-harness/raw/branch/main/install.sh -o "$prism_dir/install.sh"

Review install.sh before execution (less "$prism_dir/install.sh"), then run it from your project, in the same shell:

bash "$prism_dir/install.sh"

The installer is a Bash script: run it with bash, not sh, which is dash on Debian and Ubuntu and rejects it.

Pinned install (not yet available)

install.sh has a --verify option for minisign signatures, but no signed release has been published yet, so it cannot succeed today (it exits 4). Signed releases are planned as release assets: install.sh, its signature, and a signed manifest of every component's version and digest. The public key will be published outside the forge. Until then, download install.sh, review it, and run it with Bash.

Non-interactive (automation / AI agents)

Download and review install.sh as above, then pass --yes. It follows the same repo-aware defaults (scaffold in a repo, no new repo creation — use --target PATH to force):

bash "$prism_dir/install.sh" --yes --global --target ~/projects/my-new-thing

$prism_dir exists only in the shell that ran the download. If each of your commands starts a fresh shell, as an AI agent's tool calls often do, append && echo "$prism_dir" to the download command and use the printed directory in place of $prism_dir afterwards.

Or via environment variables:

PRISM_YES=1 bash "$prism_dir/install.sh"
PRISM_YES=1 PRISM_TARGET=~/projects/my-new-thing bash "$prism_dir/install.sh"

Flags

--global              Install all PRISM components globally (bun add -g)
--no-global           Skip the global install
--target PATH         Scaffold into PATH instead of the detected repo/cwd
                      (PATH is git-initialized if it is not inside a repo)
--no-target           Skip the target scaffold
--with-route          Include prism-route (KDL profiles + rotation + ~/.secrets/ auth)  [priority]
--no-route            Exclude prism-route
--with-loops          Include prism-loop (overnight-loop memory plugin)
--no-sober            Exclude prism-sober (Sober-Raccoon steering plugin)
--no-proxy            Exclude prism-proxy (audit + compression plugin)
--with-chat           Include prism-chat (terminal + PWA chat client)
--no-chat             Exclude prism-chat
--identity            Forge the agent's identity canon after install
--no-identity         Skip the identity forge
--identity-home PATH  Where the identity canon lives (default: ~/.prism/identity)
--mode team|solo      PRISM operating mode for the target scaffold (auto-detect
                      by default)
--verify PUBKEY       Verify install.sh with minisign against PUBKEY.
                      Not usable yet: no signed release has been
                      published, so it exits 4. See "Pinned install".
--yes                 Non-interactive (auto-accepts the four Y/n prompts).
                      Note: --identity is NOT forced by --yes — interactive by design.
--no-color            Disable colored output

Choose your operating mode

The installer asks Team-mode (prism for all) or lonely-wolf mode (prism for me)? — this decides how PRISM governs the target project:

In both modes the harness writes a root AGENTS.md reference, so the doctrine is actually loaded by whatever AI coding agent (Claude Code, Codex, OpenCode, Cursor) visits the repo — not just dropped in a folder nobody reads. Team mode is for shared codebases; lonely-wolf mode is for individual developers who want PRISM's edge without publishing their rules.

bash "$prism_dir/install.sh" --yes --mode solo --target ~/projects/my-thing    # lonely wolf
bash "$prism_dir/install.sh" --yes --mode team --target ~/projects/our-thing   # team

2. bun add -g @prism/* — sovereign npm registry

Six packages live on the sovereign Forgejo npm registry at git.sovereign-society.org/api/packages/prism/npm/ (prism-mem ships inside @prism/harness). Point bun at it via a scoped mapping in ~/.bunfig.toml, or in $XDG_CONFIG_HOME/.bunfig.toml when that variable is set. Bun reads only that one file, and an unmapped @prism scope resolves against public npm, where these names are not ours:

[install.scopes]
"@prism" = "https://git.sovereign-society.org/api/packages/prism/npm/"

Then:

bun add -g @prism/harness @prism/loop @prism/sober @prism/route @prism/proxy @prism/chat

prism-graf is not on the registry, and the meta-installer does not install it. Installing it straight from a Git URL leaves no built dist/, so no prism-graf command appears. Build it from the exact commit its v0.1.0-rc.1 tag points to. A tag name can be moved; git checkout of the full commit hash fails unless the forge serves that exact history. prism-graf has no dependencies, so the build resolves nothing:

git clone https://git.sovereign-society.org/prism/prism-graf.git
cd prism-graf
git checkout --detach f695bb669402a5447acea86dcd886bebd56b32f6   # v0.1.0-rc.1
# review the source, then:
bun run build && bun link

All eight components share one Bun runtime. The small bundles (dist/*.js) are tiny — the whole suite is ~300 KB, and bun resolves everything at install time.

Fallback

When the registry is unreachable, install.sh automatically falls back to per-component git-URL installs. To suppress the probe (e.g. on a closed-network machine), set PRISM_USE_REGISTRY=0.

GitSpawn defense post-install

The very first thing you should run after any install:

# Defend the repo you're about to open in any AI agent.
prism-harness scrub /path/to/untrusted-repo

# Audit without scrubbing (CI gate, supply-chain checks).
prism-harness scrub --dry-run --json /path/to/repo | jq .

3. Arch / CachyOS — AUR prism-harness-suite

The meta-package is on the AUR as prism-harness-suite. 1.0.0_rc.6-1 ships the GitSpawn-class defense and five packages, six components: harness (with prism-mem), loop, sober, route and proxy; prism-chat and prism-graf are not in it. Its PKGBUILD pins each of them to the commit its release tag points to (a PGP-signed git tag; the minisign-signed releases are a separate thing and not available yet) and checks every npm tarball against the sha512 in that component's lockfile; build() clones and resolves nothing. Read the PKGBUILD before you build it: an AUR package runs its maintainer's script on your machine.

git clone https://aur.archlinux.org/prism-harness-suite.git
cd prism-harness-suite
# review PKGBUILD, then:
makepkg -si

An AUR helper works too: paru -S prism-harness-suite or yay -S prism-harness-suite. Review the PKGBUILD when the helper shows it.

Local pacman repo

To serve the package to several machines, or where the AUR is unreachable, build it from the PKGBUILD in the prism-harness repository and add it to a local repo:

git clone https://git.sovereign-society.org/prism/prism-harness.git
cd prism-harness/aur/prism-harness-suite
makepkg -f
sudo install -d -m 0755 /var/lib/pacman/sync/prism-local
sudo cp *.pkg.tar.zst /var/lib/pacman/sync/prism-local/
sudo repo-add /var/lib/pacman/sync/prism-local/prism-local.db.tar.gz \
              /var/lib/pacman/sync/prism-local/*.pkg.tar.zst
# Add this section to /etc/pacman.conf (the package is built locally
# and unsigned, hence the SigLevel):
#   [prism-local]
#   SigLevel = Optional TrustAll
#   Server = file:///var/lib/pacman/sync/prism-local
# Then:
sudo pacman -Syu prism-harness-suite

After install:

prism-harness --help
prism-harness identity init    # forge the agent's eight-file canon

4. Container — prebuilt Debian image

One image with the six registry packages, each pinned by version from the sovereign registry (prism-graf is not in the image; build it from its tag as shown above), built from debian:bookworm-slim with full agent tooling (git, build-essential, python3, gnupg, apt-get). Prebuilt images are served from R2 at pkg.getharness.app — no public registry, no build required. Three modes through one entrypoint:

Download (recommended)

Immutable versioned tarballs plus a moving latest pointer, with a sha256 manifest. Current release: v1.0.0-rc.6.

# 1. Fetch the manifest and the image under its manifest name:
curl -fsSL https://pkg.getharness.app/SHA256SUMS -o SHA256SUMS
curl -fsSLO https://pkg.getharness.app/prism-prism_latest_linux_amd64.tar.gz

# 2. Verify exactly this file's manifest entry, then load (a mismatch, a
#    missing entry or a missing file all stop before load):
grep '  prism-prism_latest_linux_amd64.tar.gz$' SHA256SUMS | sha256sum -c - \
  && podman load -i prism-prism_latest_linux_amd64.tar.gz

# 3. Talk to it:
podman run --rm localhost/prism:v1.0.0-rc.6 prism harness --help

Pin a version instead of latest: https://pkg.getharness.app/prism-prism_v1.0.0-rc.6_linux_amd64.tar.gz. Downloads are counted at the edge; the sovereign VPS sees zero public traffic.

Quadlet deployment

Run it as a systemd service via Podman quadlets (systemd ≥ 254). The release repo prism-image ships a toggle pair — sandboxed (loopback-only, read-only rootfs, dropped capabilities, read-only secrets) and loose for interactive work:

git clone https://git.sovereign-society.org/prism/prism-image.git
cd prism-image/quadlet

# Sandboxed control plane (the sovereign default):
sed 's|%%VERSION%%|v1.0.0-rc.6|' prism-sandboxed.container \
  > ~/.config/containers/systemd/prism-sandboxed.container
systemctl --user daemon-reload
systemctl --user enable --now prism-sandboxed

For the always-on VPS pattern (gateway + heartbeat timer), the units live in prism-suite/containers/quadlet/:

sudo install -m 0644 prism-gateway.container prism-heartbeat.container \
                    prism-heartbeat.timer /etc/containers/systemd/
sudo systemctl daemon-reload
sudo systemctl enable --now prism-gateway.service prism-heartbeat.timer

Build it yourself (publisher flow)

Maintainers build from the prism-image repo and publish to R2; end users download above. The image pins @prism/* from the sovereign Forgejo npm registry:

git clone https://git.sovereign-society.org/prism/prism-image.git
cd prism-image
./build.sh v1.0.0-rc.6 1.0.0-rc.6    # image tag + harness registry pin
./publish.sh v1.0.0-rc.6               # podman save → gzip → R2 + SHA256SUMS

After install — identity forge

All four channels put you in the same place: a working prism-harness identity init. Run it once and the agent wakes up with a soul, a purpose, a memory, and a heartbeat. Re-running never clobbers your answer: if the eight canon files already exist, init offers to keep them (Enter keeps); only --force overwrites.

prism-harness identity init    # interactive questionnaire
prism-harness identity status  # report remaining {{PLACEHOLDER}}s