Skip to content

Latest commit

 

History

History
740 lines (567 loc) · 32.9 KB

getting-started.md

File metadata and controls

740 lines (567 loc) · 32.9 KB

Getting Started with Phantom

TL;DR

  1. Download the v0.8.7 archive for your platform, check its .sha256, and put phantom and phantom-mcp on PATH.
  2. In your project:
phantom init               # protects your .env
phantom agent doctor       # verify the repo is safe for AI agents
phantom exec -- claude     # run Claude Code through the local proxy

The archives cover macOS, Linux, and Windows. The Homebrew formula was last observed at v0.7.9, whose agent doctor does not accept --json. See distribution status for dated npm, Homebrew, crates.io, and MCP Registry evidence. A timed Linux walk-through is in First run.

That's the local setup. Keep agent dotenv reads denied and launch supported API work through phantom exec; Phantom reduces credential exposure, but it does not control unmanaged files, other processes, provider logs, or every tool an agent may invoke.


What Phantom actually does

Phantom replaces detected API keys in your .env with random 256-bit tokens (phm_...) and stores the real values in the available OS credential store or encrypted-file fallback. When you run phantom exec -- <cmd>, a local HTTP reverse proxy starts on 127.0.0.1, supported service SDKs are redirected through implemented *_BASE_URL variables, and the proxy session is authenticated with a fresh PHANTOM_PROXY_TOKEN. CLI-generated SDK URLs include the token as a local /_phantom/<token>/ path segment; header-aware clients can set PHANTOM_PROXY_HEADER_AUTH_ONLY=1 and send x-phantom-proxy-token instead. The proxy removes its local auth token, matches an exact route, discards client control of that route's auth header, and injects only the route-owned vault value into that fixed header before forwarding over TLS. Client headers and bodies never resolve phm_ tokens. Agents can use value-blind MCP metadata without dotenv read access.

All request bodies are accepted into a bounded buffer before the upstream call, so an oversized body fails with HTTP 413 before any partial mutation reaches a provider. Every accepted client body is forwarded byte-for-byte, regardless of content type or field names. Client headers are also inert; only the matched route's fixed authentication header receives a route-owned credential. SSE/streaming responses remain streamed through content-aware response scrubbing.

For a detailed breakdown of assets protected, threat actors, mitigations, and known gaps, see THREAT_MODEL.md.


Install

Exact GitHub assets (macOS, Linux, and Windows)

The immutable v0.8.7 release contains six native archives, each with a checksum sidecar and SPDX document, plus the aggregate SHA256SUMS file. All six release targets passed native acceptance before publication in workflow 42262099223.

The macOS and Linux installer commands on the landing page create a temporary phantom-install.* staging directory under TMPDIR, or /tmp when TMPDIR is unset or empty. It holds the downloaded installer script, not the installed binaries. Once the exit trap is installed, it attempts to remove the script and then the directory on exit, including after a command fails. The directory is removed only if it is empty; cleanup can fail and is not guaranteed. These details apply to the landing-page commands, not the manual archive steps below.

Platform v0.8.7 archive Published checksum
macOS Apple silicon phantom-aarch64-apple-darwin.tar.gz sha256
macOS Intel phantom-x86_64-apple-darwin.tar.gz sha256
Linux x86_64 phantom-x86_64-unknown-linux-gnu.tar.gz sha256
Linux ARM64 phantom-aarch64-unknown-linux-gnu.tar.gz sha256
Windows x64 phantom-x86_64-pc-windows-msvc.zip sha256
Windows ARM64 phantom-aarch64-pc-windows-msvc.zip sha256

Download the archive and its sidecar, then verify before extraction. On Linux, sha256sum -c accepts the published sidecar. On Windows, compare Get-FileHash -Algorithm SHA256 <archive> with the sidecar. Put both extracted executables on PATH.

Linux x86_64, as one shell script:

archive=phantom-x86_64-unknown-linux-gnu.tar.gz
base=https://github.com/ashlrai/phantom-secrets/releases/download/v0.8.7
curl -fsSL -o "$archive" "$base/$archive"
curl -fsSL -o "$archive.sha256" "$base/$archive.sha256"
sha256sum -c "$archive.sha256"
tar -xzf "$archive"
mkdir -p "$HOME/.local/bin"
install -m 0755 phantom phantom-mcp "$HOME/.local/bin/"
export PATH="$HOME/.local/bin:$PATH"
phantom --version
phantom-mcp --version

Use the ARM64 archive name from the table on ARM64 Linux. The same steps on the measurement VM are recorded in First run.

Homebrew (macOS; last observed formula v0.7.9)

brew tap ashlrai/phantom
brew trust --formula ashlrai/phantom/phantom
brew install ashlrai/phantom/phantom

The formula was last observed installing both phantom and phantom-mcp from the immutable v0.7.9 release, not v0.8.7. That version's phantom agent doctor does not accept --json; use the archives above for the current release. Installs from the former v0.7.8 formula registered Claude Code MCP in the legacy location; after brew upgrade, rerun phantom setup --client claude to migrate, or see the Claude Code guide for the manual step.

Build the exact release source

git clone https://github.com/ashlrai/phantom-secrets.git
cd phantom-secrets
git checkout a6a0413991c0bd7f3d6601f467c0b5770d0dce0c
cargo build --release --locked --bin phantom --bin phantom-mcp

The full SHA above is the source commit resolved by v0.8.7. See distribution status for dated npm, Homebrew, crates.io, and MCP Registry evidence. Prefer the checksum-verified v0.8.7 GitHub assets for an exact install.

Verify

phantom --version
phantom-mcp --version
# phantom 0.8.7
# phantom-mcp 0.8.7

The last dated Homebrew observation recorded 0.7.9; see the distribution status for channel observations. The exact GitHub assets above are 0.8.7.


First run

Create a project .env, then run phantom init in that directory. The published v0.7.9 Linux binary, measured in First run, prints this shape for one detected API key:

-> Reading .env...
-> Found 1 secret(s) to protect:
   + OPENAI_API_KEY
-> Using linux-keyutils (volatile across reboot) vault backend
   + OPENAI_API_KEY -> phm_<12 characters shown>
ok Rewrote .env with phantom tokens
ok Saved .phantom.toml
ok Generated .env.example
done 1 secret(s) are now protected!
ok Added Phantom instructions to CLAUDE.md

That binary then suggests phantom login, phantom open, and pre-commit install. None of those is required to store a secret and run phantom exec. The .pre-commit-hooks.yaml file used by pre-commit install is in this repository and is not one of the 19 files attached to the v0.7.9 release. Source in this tree leads the next steps with phantom agent doctor, phantom setup, and phantom exec, and it warns that keyutils is cleared on reboot.

The protected value in .env is a phm_ token. In the measurement the file token was 68 characters and the init line showed 12 of them. NODE_ENV and PORT stayed as written. .env.example received placeholders, and .gitignore gained .env.

Linux keyutils does not survive a reboot. Keep a provider or password-manager copy, or export PHANTOM_VAULT_PASSPHRASE before phantom init to select the encrypted-file vault. The later section on Linux keychain covers that choice.

If your .env is at a non-standard path:

phantom init --from .env.local

phantom init does not create a plaintext project backup. Keep an independent provider or password-manager recovery source, or use Phantom's encrypted export below. phantom unwrap is unrelated to secret recovery: it only restores package.json scripts previously changed by phantom wrap.

Connection strings such as DATABASE_URL are detected, vaulted, and replaced in dotenv files, but they are not proxied. phantom exec fails closed when a protected connection string is present because injecting the real URL into the child environment would put the credential back inside the agent boundary. A protocol-aware database broker is planned; until then, split API-key work from database work or use a separately approved trusted-terminal workflow.


Core commands

phantom init

Reads .env, stores real secrets in the OS keychain, rewrites .env with phantom tokens, and creates .phantom.toml. A completed run may be repeated from the same real project directory: new secrets are added and existing phantom tokens are preserved. Phantom retains that project directory while the transaction runs, so renaming its ambient path and replacing it with a decoy does not redirect the in-progress write.

Do not blindly rerun after a CommittedButUncertain, durability, or Partial effect warning. A rename, unlink, or directory creation may already have committed before its final durability check failed. Run phantom doctor, inspect the intended project and current path from a trusted terminal, and reconcile the reported file before trying again.

phantom init
phantom init --from .env.local

Multi-project — process eligible repos found by the bounded workspace scan:

phantom init --all ~/code --dry-run    # preview which repos would be touched
phantom init --all ~/code              # process the exact repos shown by dry-run
phantom init --all ~/code --jobs 8     # run up to 8 repos concurrently (default: 4)

--all scans at most five directory levels for repositories containing a supported dotenv filename and stops descending below the first matching repository. It skips already-protected repositories, dot-directories, and known dependency/build directories. Always review --dry-run; deeper or nested repositories may require their own invocation. A progress bar shows live status, and PHANTOM_INIT_JOBS can set the default parallelism.

phantom add / phantom remove

phantom add requires an initialized project and never auto-creates config, gitignore, or vault state. In a new project with no dotenv file, run phantom init --empty once before the first add.

# New project only:
phantom init --empty

# Interactive prompt — value is read silently from the terminal (no echo):
phantom add STRIPE_SECRET_KEY

# Pipe the value from a secret manager or CI helper (no tty required):
echo "$SECRET_VALUE" | phantom add STRIPE_SECRET_KEY --stdin
op read "op://Prod/Stripe/key" | phantom add STRIPE_SECRET_KEY --stdin

phantom remove STRIPE_SECRET_KEY

add creates a new protected name, stores its value, and writes a phantom token to .env. It prompts silently so the secret never enters shell history or the process list. Positional secret values are rejected; use --stdin only with a trusted producer. --stdin reads up to EOF (trailing newlines are dropped, 64 KiB cap) and is refused when stdin is a terminal. Input with more than one line is refused before anything is stored unless you say what to keep: --multiline stores every line (a PEM key, a JSON document), --first-line stores only line 1 (pass show svc/api | phantom add API_KEY --stdin --first-line, since pass and gopass put metadata after the key). An existing protected name is denied from value-blind vault metadata before Phantom reads the prompt or stdin. add never replaces it. remove requires attached stdin/stdout/stderr plus an exact typed challenge, then transactionally removes the vault value, lifecycle config, and exact managed-dotenv mapping. Removing and later re-adding the same name is an explicit, non-atomic two-command workflow.

phantom rotate

Regenerates all project phantom tokens without changing the real secrets. This invalidates every current mapping, so the command requires attached stdin, stdout, and stderr plus an exact typed challenge bound to the canonical project, exact config and managed-dotenv snapshots, and the sorted protected-name digest. Headless calls fail before vault access or mutation, and state drift after approval aborts the write. A phm_ value is not accepted by the upstream provider and client requests never resolve it. Still rotate exposed mappings: unmanaged dotenv entries remain possible, and a process with the active proxy bearer can invoke configured provider routes using route-owned authentication.

phantom rotate

phantom cloud push / phantom cloud pull

These source-backed commands require a separately verified hosted deployment and account entitlement; the public hosted service is not currently commissioned for authenticated use. After commissioning, they can back up and restore your vault on the same keychain machine using client-side encryption. The cloud vault API receives ciphertext rather than decrypted secret values; client, endpoint, account, and OS-keychain security remain part of the trust boundary. Phantom does not currently transfer or recover the machine-local cloud encryption key.

phantom login              # GitHub OAuth, once per device
phantom cloud push         # upload encrypted vault
phantom cloud pull         # restore where the original cloud key is available

Run login and cloud writes only from a terminal outside the requesting agent's authority. Login has separate exact challenges before network access and before browser opening/polling/keychain persistence. Push and pull each show a value-blind effect and require their exact typed challenge before credential, vault-value, or network access. A force=false pull that skips any existing entry retains the prior merge base and blocks push until a fully reconciled, approved pull.

phantom sync / phantom pull

Push real secrets to a deployment platform, or pull them from one.

# Push to Vercel
phantom sync --platform vercel --project prj_abc123

# Push only Stripe secrets (glob pattern — avoids dev-only keys going to prod)
phantom sync --platform railway --project <id> --only "STRIPE_*"

# Multiple --only flags are OR-ed together
phantom sync --platform vercel --project prj_abc123 --only "STRIPE_*" --only "*_KEY"

# Preview without decrypting values or touching platform APIs
phantom sync --platform vercel --project prj_abc123 --dry-run --json

# Pull from Vercel with authorized provider access
phantom pull --from vercel --project prj_abc123

# Railway
phantom sync --platform railway --project <id>
phantom pull --from railway --project <id> --environment production

You can also hard-code filters per [[sync]] block in .phantom.toml so that phantom sync (no flags) always respects them:

[[sync]]
platform     = "railway"
token_env    = "RAILWAY_TOKEN"
project_id   = "<id>"
only         = ["STRIPE_*", "SENDGRID_*"]   # never push DEV_* or DEBUG_* to prod

phantom check

Scans supported dotenv files for heuristically detected secrets. With --staged, it also checks staged dotenv content and a bounded set of hardcoded-key prefixes on added lines. Use it as one pre-commit layer, not as a complete repository secret scanner.

phantom check
# BLOCKED Unprotected secrets detected!
#   ! .env: OPENAI_API_KEY is not protected
# fix Run `phantom init`

Exit code 0 = clean. Exit code 1 = unprotected secrets found.

Agents and CI can add --json (or the global phantom --json check) to get one report on stdout instead of the human text. It lists names, paths and pattern labels only, never values or phantom tokens, and keeps the same exit codes. A scan whose result is indeterminate is still an error with no report.

{
  "mode": "worktree",
  "clean": false,
  "findings": [{ "kind": "dotenv", "path": "/repo/.env", "name": "OPENAI_API_KEY" }],
  "warnings": []
}

mode is worktree, staged or runtime. Each finding's kind is dotenv, staged_dotenv, staged_code (with label and pattern) or runtime_env. warnings lists risky .phantom.toml routes found in staged config.

phantom doctor

Health check for your setup: config validity, vault access, .env protection, .gitignore coverage, .env.example, pre-commit hook.

phantom doctor
phantom doctor --fix    # auto-fix safe issues
phantom doctor --strict # exit 2 when any issue is present, including warnings
phantom why OPENAI_API_KEY --strict

phantom doctor --strict exits 2 when the report has any issue. Warnings count the same as failures. There is no severity weighting. Omit --strict to keep the current exit status: a finished report with issues still exits 0. Exit 1 stays a command error. phantom why KEY --strict uses that same table. It exits 2 when the key is not protected, and a JSON report for a missing key also exits 2. The human view of a missing key is still a command error (exit 1). Without --strict, a present key still exits 0.

phantom doctor --json (or phantom --json doctor) prints one report on stdout for agents and CI: ok, issues, fixed, a checks list of {status, message, fix?, fixed?} with status pass, fail, warn or info, and mcp_clients with each client's config path and state (local_runtime, stale, unreadable, not_phantom or not_configured). Messages are the same value-blind text as the human checklist, and the exit status is unchanged unless --strict is also set. A configured managed dotenv that is missing or cannot be read safely (for example a symlink) is a fail check named "Managed dotenv" with a fix hint; the other checks still run. phantom doctor --fix stops with an error before any repair in that state.

$ phantom doctor
pass: .phantom.toml found
pass: Config valid (project: a1b2c3d4)
pass: Vault backend: macOS Keychain
pass: 3 secret(s) in vault
pass: .env has 5 entries and no unprotected secrets
pass: .env is in .gitignore
warn: No .env.example — team onboarding may be difficult
warn: No pre-commit hook installed

2 issue(s) found — use --fix to auto-fix

phantom agent

One command answers whether this repo is ready for autonomous AI coding tools.

phantom agent doctor          # human-readable readiness view
phantom agent doctor --json --strict # exit 2 unless the verdict is ready
phantom agent report --json   # stable JSON for automation and CI
phantom agent setup --dry-run # preview safe setup changes
phantom agent setup --apply   # initialize safe defaults

phantom agent doctor --json --strict uses the same exit table as phantom doctor --strict: exit 0 when the verdict is ready, exit 2 when it is degraded, blocked, or unknown, and exit 1 for a command error. Without --strict the JSON exit stays 0. Key on schema (phantom.agent.doctor.v1). The .vN suffix changes only when the JSON shape breaks. schema_version and kind (phantom.agent.preflight) stay for older readers. See docs/agent-preflight-contract.md.

The readiness engine checks .env files, .phantom.toml, vault access, unprotected secrets, .env.example, .gitignore, MCP client wiring, package script wrapping, pre-commit protection, audit status, cloud login, team state, and sync targets. It returns one state: unsafe, protected, verified, team-ready, or compliance-ready. A locked encrypted-file vault (secrets stored with PHANTOM_VAULT_PASSPHRASE, which this shell lacks) and a missing or unresolvable managed dotenv (managed-dotenv-unresolved) are critical findings: the state is unsafe and the command exits 1.

phantom reveal

Print a real secret value to stdout. Blocked in non-interactive contexts by default.

phantom reveal OPENAI_API_KEY
phantom reveal OPENAI_API_KEY --clipboard   # trusted terminal + exact typed confirmation

Editor integrations

One command per AI client — Phantom writes the right config file in the right place:

phantom setup --client claude     # project MCP; see claude-code.md for v0.7.9 migration
phantom setup --client cursor     # ~/.cursor/mcp.json
phantom setup --client windsurf   # ~/.codeium/windsurf/mcp_config.json
phantom setup --client codex      # ~/.codex/config.toml
phantom setup --client gemini     # ~/.gemini/settings.json
phantom setup --status            # read-only client wiring status
phantom setup --client claude --print   # snippet to stdout for any other client

Install both v0.8.7 release binaries before setup. Version 0.8.7 records the running phantom executable with mcp serve when it can resolve that executable, otherwise it looks for a local standalone phantom-mcp. Setup has no network package-runner fallback and fails closed when neither local runtime is executable. Keep both verified release binaries installed and inspect the generated entry. For Claude Code, setup removes legacy Phantom-managed dotenv read grants and preserves deny rules; agents use value-blind MCP inventory instead. See claude-code.md for the full workflow. Runtime MCP tools/list is the canonical catalog.

Restart the AI tool after running phantom setup so it picks up the new config.

Run phantom agent doctor after setup to confirm the repo is ready before handing work to Claude Code, Codex, Cursor, Windsurf, or another agent.


Audit log (opt-in)

For compliance or forensics, set PHANTOM_AUDIT=1 to record every vault store/retrieve/delete to ~/.phantom/audit.log:

export PHANTOM_AUDIT=1
phantom exec -- npm run dev

Each line is a JSON object with ts, op, name (the secret name — never the value), process, and pid. Off by default; turn on per-shell or in your .envrc / .zprofile.

Viewing and verifying the log

# Print the last 50 events (default)
phantom audit show

# Filter by operation or secret name
phantom audit show --op vault.store --name OPENAI_API_KEY

# Follow the log live (like tail -f)
phantom audit tail

# Print the absolute path to the log file
phantom audit path

# Verify HMAC-SHA256 chain integrity; exits 1 on verification failure
phantom audit verify

# List access-spike alerts without writing to the audit log
phantom audit hotspots --json

Each log entry is chained with HMAC-SHA256 and a signed head checkpoint. phantom audit verify detects malformed lines, modified or inserted entries, sequence gaps, prefix deletion, and log tail/head mismatches. It cannot prove the whole log and checkpoint were both deleted without an external backup or checkpoint. On failure, follow the printed next steps; phantom audit verify --json provides them in next_step. --with-context displays decrypted context and cannot be combined with JSON.

phantom audit hotspots lists per-secret access spikes. Use --name NAME to filter and --include-acked to include acknowledged or snoozed alerts. Listing is read-only; acknowledgement and snoozing use the approval-gated MCP tool phantom_audit_hotspot_alerts.


Encrypted backup and recovery

With stdin, stdout, and stderr attached to a terminal outside agent authority, Phantom displays a value-blind plan and requires its fresh exact typed challenge before secret transfer. Export then reads a dedicated passphrase without echoing it or placing it in command-line arguments; import has a separate ceremony:

phantom export --output phantom-backup.enc
phantom import phantom-backup.enc

Export rejects --passphrase-file on every platform because the invoking agent could retain the decryption material; use the attached hidden terminal prompt. For import only, non-Windows operators may provide the passphrase through a bounded private regular file after the terminal ceremony. On Unix, that file must be mode 0600 or stricter; symlinks and non-regular files are rejected. Import passphrase files fail closed on Windows.

chmod 600 /secure/path/phantom-backup.pass
phantom import phantom-backup.enc \
  --passphrase-file /secure/path/phantom-backup.pass

The output path must be new. Phantom never overwrites an existing file or symlink and creates the encrypted archive atomically, with mode 0600 on Unix and the containing directory's inherited ACL on Windows. Store the archive and its passphrase separately. The former --passphrase argv option is retained only to return a migration error because process inspection and shell history can expose command-line arguments.


Importing from other secret managers

Migrate secrets from Doppler, Infisical, dotenvx, 1Password, or a plain .env file without exposing values in your shell:

# Doppler: export secrets as JSON first, then import
phantom import --from doppler --file dump.json

# Infisical: export as .env (or --format=json), then import
phantom import --from infisical --file export.env

# dotenvx: import a plaintext .env (not an encrypted .env.vault)
phantom import --from dotenvx --file .env

# 1Password: collect fields into a flat {"KEY": "value"} JSON object, then import
phantom import --from 1password --file 1p-export.json

# Plain .env file (same heuristics as phantom init)
phantom import --from env --file .env

See Troubleshooting for each source's exact file format.

After importing, run phantom init to replace any remaining plaintext secrets in your .env with phantom tokens.

Use --force to select existing vault entries for overwrite in the displayed exact plan. It never bypasses attached-terminal consent, and a source/config identity change invalidates the ceremony before storage.


Troubleshooting

"No .phantom.toml found"

You haven't initialized in this directory.

phantom init

For a new project with no dotenv file, use phantom init --empty before the first phantom add; add never auto-creates project state.

API calls return 401 after setup

The proxy is not running or the *_BASE_URL variables aren't set. Always run your tool via phantom exec:

phantom exec -- node server.js
phantom exec -- claude

Check status:

phantom status
phantom doctor

Keychain access prompt on macOS

Click "Always Allow" for the phantom-secrets entry. This appears once per application.

Linux keychain unavailable / CI environments

Linux starts with the kernel keyutils backend, whose entries do not survive a reboot. On a desktop with an unlocked Secret Service, migrate one initialized project from a terminal you exclusively control:

phantom vault migrate-linux

Phantom previews a value-free, state-bound plan and requires its exact challenge before reading vault values. It copies and verifies every indexed credential, keeps the keyutils source entries, and only then publishes independent owner-only config-root and data-root backend records. Conflicting persistent values or an unavailable/locked Secret Service fail closed. If a completed project's Secret Service is later unavailable, normal vault access fails rather than silently falling back to keyutils.

Keep Phantom's private application-data and configuration directories in your workstation backup. Migration writes independent anchored records beneath both roots plus a Secret Service corroboration sentinel. If either local record is missing after a reboot, ordinary access fails closed without probing or prompting Secret Service; the explicit migration command can verify and repair the prepared state. Normal projects with neither marker remain on keyutils. If all local Phantom state is deleted, restore a verified backup; Phantom cannot infer the former backend safely.

For CI, WSL, servers, or any environment without a reliably unlocked desktop Secret Service, select the encrypted-file vault explicitly:

Set a passphrase and Phantom falls back to an encrypted file vault:

export PHANTOM_VAULT_PASSPHRASE="$(openssl rand -hex 32)"

Store this passphrase as a CI secret. See docs/ci-cd.md for full GitHub Actions and Docker examples. phantom exec uses the passphrase only in its trusted parent process, then removes PHANTOM_VAULT_PASSPHRASE from both proxied and direct child environments. Commands launched manually from the same shell still inherit the export, so avoid launching agents outside phantom exec while it is set.

An older registry-based install command fails

The reviewed binaries ship from the immutable v0.8.7 GitHub Release, not the older registry tracks. Download and verify the platform asset above, or build the exact tagged source:

git clone https://github.com/ashlrai/phantom-secrets.git
cd phantom-secrets
git checkout a6a0413991c0bd7f3d6601f467c0b5770d0dce0c
cargo build --release --locked --bin phantom --bin phantom-mcp

The full SHA above is the source commit resolved by v0.8.7.

Claude Code cannot read .env after setup — is this broken?

No. A phm_ value is not a provider credential, but keeping dotenv reads denied also protects unmanaged sibling files and backups created by other tools. It also reduces exposure of mappings that an authenticated active Phantom proxy could resolve. phantom setup --client claude wires MCP while removing legacy Phantom-managed dotenv read grants; agents use value-blind metadata instead.


Dashboard

After a hosted deployment and account entitlement are independently commissioned and accepted, its read-only dashboard is designed to show project, vault-size, last-sync, plan, and team metadata. The public phm.dev service is not currently commissioned for authenticated use, so this is not a live dashboard claim.

$ phantom open
# After hosted commissioning, attached-terminal review, and an exact typed
# challenge, opens the configured dashboard. Closed aliases only:
# phantom open billing | team | docs | github | pricing

phantom open also accepts dashboard, issues, and site (plus the documented teams, repo, and home synonyms). Arbitrary URLs, schemes, credentials, paths, and unknown aliases are rejected before browser access.

Next steps

Where Phantom fits

Phantom Secrets is one of the open-source tools from Ashlr. Together they aim to be an autonomous, code-first, agent-native software factory: agents write, test, review, and ship the code, and the human acts as a passive board member. The long-term goal is open-source recursive self-improvement (RSI), where agents improve the tools they build with.

This repo's part is keeping real API-key values out of agent context. The other tools (Phantom, Locus, Lexicon, Ashlr MD, Ashlr Stack, and ashlr-plugin) each install and run on their own; the README's ecosystem section links them.

Coding agents make most changes to this repo through normal pull requests and CI. See How agents work on this repo and AGENTS.md.