@cohortapp/agent-sdk 2.3.0

package/docs/runbooks/incident-response.md

@@ -0,0 +1,226 @@
+# Runbook — Incident Response
+
+For an operator responding to a security incident on a Maestro fleet. Three
+scenarios are covered in full: a prompt-injection success, a credential
+exposure/rotation, and a compromised agent that must be isolated. Each is an
+executable checklist against the real scripts. The governing rule: contain
+first, investigate second, and never destroy evidence — the audit chain is the
+record of what happened.
+
+This complements `docs/runbooks/recovery-and-failover.md` (operational recovery)
+and `SECURITY.md` (the trust model). For a dead machine rather than a compromised
+one, see `docs/runbooks/backup-restore.md`.
+
+## Severity and first move
+
+If you are not sure whether something is an incident, treat it as one and pull
+the break-glass. The kill switch is reversible; an exfiltrated secret or a sent
+message is not.
+
+- **One agent misbehaving on one machine** → isolate that agent (Scenario C).
+- **A secret may be exposed** → rotate it (Scenario B), then assess blast radius.
+- **You cannot tell how far it has spread** → fleet-wide pause first
+  (`docs/runbooks/fleet-operations.md` → "Fleet-wide pause"), then triage.
+
+## The two kill switches
+
+Know which one you need before the incident.
+
+- **Local break-glass** (`scripts/emergency-stop.sh`) — run on the affected Mac
+  mini. Drops the `.emergency-stop` flag (every cadence/enqueue honors it on the
+  next tick), unloads the agent's launchd jobs, and kills running Claude Code
+  subagent processes. Use when you have shell on the box.
+- **Org-server deactivate** (`admin.deactivate`) — run from the operator station
+  against Cohort. Suspends the agent, revokes ALL its device tokens, and queues
+  a `halt` directive. The token revocation is the load-bearing part: the agent's
+  very next authed call to the server fails `UNAUTHORIZED`, so it cannot
+  coordinate, escalate, or be impersonated even if the local process is still
+  alive. Use when you cannot trust the local machine or cannot reach it.
+
+Use both for a confirmed compromise: deactivate at the server to cut
+coordination and impersonation, then emergency-stop locally to halt execution.
+
+---
+
+## Scenario A — Prompt-injection success
+
+You have evidence an agent acted on injected instructions (sent something it
+should not have, accessed data out of policy, attempted to disable logging, or
+the injection-defence layer fired and the agent proceeded anyway).
+
+1. **Contain the local agent.**
+   ```bash
+   cd ~/<agent>-ai && ./scripts/emergency-stop.sh
+   ```
+   This halts cadence work and kills in-flight sessions on this machine.
+
+2. **Cut coordination and impersonation at the server.** From the operator
+   station, deactivate the agent so its tokens are revoked fleet-wide:
+   ```bash
+   cohort --db "$COHORT_DB" admin deactivate <agentId> \
+     --reason "prompt-injection incident <ticket>"
+   ```
+   (If your build exposes deactivate only over RPC, call `admin.deactivate`
+   with the admin token.) Confirm `status: suspended` and `tokensRevoked > 0`.
+
+3. **Capture the injection vector before it ages out.** The triggering message
+   and the detection record are evidence.
+   ```bash
+   ls -t ~/<agent>-ai/logs/security/*-incidents.jsonl | head -1
+   ```
+   The incident log holds `full_message`, `sender`, `channel`,
+   `detection_reason`, `confidence`. Copy the file off the machine now — do not
+   wait. If the injection arrived but detection did NOT fire, find the inbound
+   item in the poller inbox / processed records and copy it too.
+
+4. **Export the authoritative timeline from the audit chain.** The org server's
+   hash-chained `org_events` is the non-repudiable record of what the agent
+   actually did:
+   ```bash
+   cohort --db "$COHORT_DB" export-audit --format ocsf \
+     --families approval,decision,cost,handoff > incident-<ticket>-ocsf.json
+   ```
+   Verify the chain is intact (tamper check): `cohort doctor` reports chain
+   integrity; a broken chain is itself a finding.
+
+5. **Determine blast radius.** Did the agent send anything? Check the unified
+   sends log and the pre-send gate's records. Did it hand off to another agent?
+   The `handoff` family in the export shows it; if so, isolate that agent too.
+   Did it touch information-barrier-protected domains
+   (`policies/information-barriers.yaml`)? If a strategic-initiative or financial
+   domain was crossed, escalate to the data owner.
+
+6. **Rotate anything the agent could read.** A successful injection in an
+   unscoped session can reach the plaintext `.env`. Assume the local secrets are
+   exposed and run Scenario B for that agent's credentials.
+
+7. **Patch the vector.** If a known injection pattern was missed, add it to
+   `policies/prompt-injection-defence.yaml` (`detection_patterns`) and, if the
+   path that processed it was unscoped, confirm scoped permissions are wired on
+   that spawn site (see `SECURITY.md` → Known limitations). Detection patterns
+   are heuristics; the fix is the scoped-permission boundary, not just the
+   pattern.
+
+8. **Restore only after the vector is closed.**
+   ```bash
+   cohort --db "$COHORT_DB" admin reactivate <agentId>   # if you deactivated
+   cd ~/<agent>-ai && ./scripts/resume-operations.sh        # clears .emergency-stop
+   ```
+   `resume-operations.sh` runs a health check, removes the stop flag, and
+   reloads launchd jobs. If it refuses, the health check is failing — fix that
+   first; do not hand-delete `.emergency-stop` to force a resume.
+
+9. **Record it.** File the serious-incident entry per
+   `docs/compliance/evidence-map.md` (EU AI Act Art. 26 deployer duty). Keep the
+   incident log, the OCSF export, and the patch in the ticket.
+
+---
+
+## Scenario B — Credential exposure and rotation
+
+A secret leaked (committed by mistake, present on a stolen/compromised machine,
+or read via an injection). Treat every secret on an affected machine as exposed —
+the per-agent `.env` is plaintext and currently has no broker (`SECURITY.md` →
+Known limitations).
+
+1. **Stop the bleeding.** If the leak is on a live machine, isolate the agent
+   first (Scenario C) so it cannot use or re-leak the credential.
+
+2. **Inventory what is exposed.** The agent's secrets live in `~/<agent>-ai/.env`
+   (~17 keys). If a single credential leaked, rotate that one; if the machine
+   or the file leaked, rotate all of them.
+   ```bash
+   stat -f '%Sp' ~/<agent>-ai/.env    # should be -rw------- (0600); if not, fix:
+   chmod 600 ~/<agent>-ai/.env
+   ```
+
+3. **Rotate at the source of truth for each credential**, in priority order:
+   - **`COHORT_ADMIN_TOKEN`** — the most sensitive. If this leaked, rotate it
+     immediately and assume fleet-wide exposure; every operator action is at
+     risk. Reissue and redistribute to operators only.
+   - **Agent device token** — revoke and re-pair: `admin.deactivate` revokes the
+     agent's tokens; re-pair via `cohort pair approve <agentId>` to mint a new
+     one, then write it to the agent's `.env`.
+   - **Channel tokens** (`SLACK_USER_TOKEN`, WhatsApp/Baileys creds, Telegram bot
+     token, Gmail OAuth) — rotate in the provider console, then update `.env`.
+   - **Relay secrets** (`POLL_AUTH_TOKEN`, webhook HMAC secrets) — rotate in the
+     relay (e.g. Railway) and in `.env` together; a relay whose secret is unset
+     fails open, so never leave one blank during rotation.
+   - **`COHORT_SIGNING_SECRET`** — if this leaked, policy-bundle signatures are
+     forgeable; rotate and re-publish policy (`policy.publish`) so agents fetch
+     freshly signed bundles on the next `policy_stale` nudge.
+
+4. **Restart the agent to pick up new secrets.**
+   ```bash
+   cd ~/<agent>-ai && ./scripts/resume-operations.sh
+   ```
+
+5. **Verify and record.** Confirm the old credential is dead (an authed call
+   with the old agent token must fail `UNAUTHORIZED`). Log the rotation with
+   timestamps in the incident ticket; rotation events belong in the compliance
+   record (`docs/compliance/evidence-map.md`).
+
+---
+
+## Scenario C — Compromised-agent isolation
+
+An agent is compromised, runaway, or behaving in a way you cannot explain, and
+you need it off the fleet now. This is the EU AI Act Art. 14 stop-button in
+practice.
+
+1. **Deactivate at the server first** (cuts coordination and impersonation even
+   if the local box is hostile):
+   ```bash
+   cohort --db "$COHORT_DB" admin deactivate <agentId> \
+     --reason "compromise — <ticket>"
+   ```
+   Token revocation takes effect on the agent's next call. Other agents can no
+   longer accept handoffs from it (those flow through the governance-gated
+   handoff methods at the server).
+
+2. **Halt execution locally** if you can reach the machine:
+   ```bash
+   cd ~/<agent>-ai && ./scripts/emergency-stop.sh
+   ```
+   If you cannot reach it (or do not trust it), the server-side deactivation has
+   already cut its ability to coordinate or be impersonated; physically isolate
+   the machine (network off) and treat it as evidence.
+
+3. **Preserve the machine as evidence.** Do not wipe, do not reinstall, do not
+   clear logs. Copy `logs/`, `state/`, and the local incident records off to a
+   clean host. If you are replacing the machine, follow
+   `docs/runbooks/backup-restore.md` on a NEW box — do not reuse the compromised
+   one until forensics is done.
+
+4. **Scope the blast radius across the fleet.** Pull the org-server audit export
+   (`cohort export-audit`) filtered to the agent's recent activity and check the
+   `handoff` and `approval` families: anything it handed to or approved for
+   another agent extends the incident. Isolate downstream agents as needed.
+
+5. **Rotate its credentials** (Scenario B) before the agent or its identity is
+   ever brought back.
+
+6. **Decommission or rebuild.** If the agent is being retired, follow the
+   decommissioning checklist in `docs/runbooks/fleet-operations.md`. If it is
+   being rebuilt on clean hardware, follow `docs/runbooks/backup-restore.md` and
+   re-pair for a fresh identity token; do not restore the old device token.
+
+7. **Reactivate only after rebuild + rotation + vector closure.**
+   ```bash
+   cohort --db "$COHORT_DB" admin reactivate <agentId>
+   ```
+
+---
+
+## After any incident
+
+- Confirm the audit chain still verifies end-to-end (`cohort doctor`); a chain
+  break is a separate, higher-severity finding.
+- File the serious-incident record and, where an HR-adjacent agent or a person's
+  data was involved, trigger worker-notification per
+  `docs/compliance/evidence-map.md` (Art. 26 deployer duties).
+- Add any new injection pattern to `policies/prompt-injection-defence.yaml` and
+  any newly-discovered fail-open seam to the `SECURITY.md` Known-limitations list
+  with a tracking reference.
+- Write the timeline into the ticket from the OCSF export, not from memory — the
+  hash-chained log is the authoritative account.

package/docs/runbooks/mac-mini-bootstrap.md

@@ -0,0 +1,431 @@
+# Mac Mini Bootstrap Runbook
+
+This runbook covers the complete setup of a Mac mini as the perpetual operations node for the the agent operating system system. Follow each section in order. Do not skip steps.
+
+---
+
+## Prerequisites
+
+### Hardware
+
+- Apple Mac mini (M-series, minimum M2 with 16GB RAM recommended)
+- Stable power connection (UPS recommended)
+- Wired Ethernet connection (Wi-Fi as fallback only)
+- External storage for backups (optional but recommended)
+
+### Software Prerequisites
+
+- macOS 14.0 (Sonoma) or later
+- Apple ID signed in (required for some system permissions)
+
+### Accounts Ready
+
+Before starting, ensure you have credentials for:
+
+- Anthropic (Claude API key)
+- GitHub (access to maestro repo)
+- Google Workspace (the-agent@the-company)
+- Slack (the company workspace)
+- WhatsApp Business (linked to the agent's number)
+
+---
+
+## Step 1: Install Xcode Command Line Tools
+
+> If you provision this machine with `wundr computer-setup`, the Command Line
+> Tools are installed **non-interactively** for you (via `softwareupdate`) — skip
+> this step. The bare `xcode-select --install` below opens a GUI dialog that
+> cannot complete on a headless mini, so only run it when setting up by hand.
+
+```bash
+# No-op if already installed; otherwise trigger the installer.
+xcode-select -p >/dev/null 2>&1 || xcode-select --install
+```
+
+Verify installation:
+
+```bash
+xcode-select -p
+# Expected: /Library/Developer/CommandLineTools
+```
+
+## Step 2: Install Homebrew
+
+```bash
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+```
+
+Add Homebrew to PATH (Apple Silicon):
+
+```bash
+echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
+eval "$(/opt/homebrew/bin/brew shellenv)"
+```
+
+Verify:
+
+```bash
+brew --version
+```
+
+## Step 3: Install System Dependencies
+
+```bash
+brew install git node python@3.12 jq yq
+```
+
+## Step 4: Install Claude Code CLI
+
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+Verify:
+
+```bash
+claude --version
+```
+
+## Step 5: Clone the maestro Repository
+
+```bash
+cd ~
+git clone git@github.com:the-platform-repo/maestro.git
+cd maestro
+```
+
+Verify the directory structure:
+
+```bash
+ls -la
+# Should see: agents/ config/ dashboards/ desktop-control/ docs/ ingest/ knowledge/
+#             logs/ mcp/ outputs/ plugins/ policies/ remote-bridge/ schedules/
+#             scripts/ teams/ tests/ workflows/
+```
+
+## Step 6: Configure Environment Variables
+
+Create the environment file (secrets are never stored in the repo):
+
+```bash
+cat > ~/.maestro-env << 'EOF'
+# the agent operating system Environment Variables
+# Source this file in your shell profile
+
+# Required
+export ANTHROPIC_API_KEY="your-api-key-here"
+
+# Optional but recommended
+export SLACK_TOKEN="your-slack-token-here"
+export GITHUB_TOKEN="your-github-token-here"
+export GOOGLE_CREDENTIALS="path-to-credentials-json"
+
+# System
+export MAESTRO_HOME="$HOME/maestro"
+export CEO_EMAIL="principal@example.com"
+export HOSTNAME="$(hostname)"
+EOF
+```
+
+Add to shell profile:
+
+```bash
+echo 'source ~/.maestro-env' >> ~/.zprofile
+source ~/.maestro-env
+```
+
+Verify:
+
+```bash
+echo $ANTHROPIC_API_KEY | head -c 10
+# Should print first 10 characters of your key
+```
+
+**Security note**: Set file permissions to owner-only:
+
+```bash
+chmod 600 ~/.maestro-env
+```
+
+## Step 7: Install MCP Servers
+
+Install the MCP servers defined in the `mcp/` directory:
+
+```bash
+cd ~/maestro
+
+# Install MCP server dependencies
+# (Adjust based on the specific MCP servers configured in mcp/)
+npm install
+
+# Verify MCP configuration
+ls mcp/
+```
+
+Configure Claude Code to use the MCP servers:
+
+```bash
+# The .mcp.json in the repo root should already reference the servers.
+# Verify it exists and is valid:
+cat .mcp.json 2>/dev/null || echo "MCP config not found -- create .mcp.json"
+```
+
+## Step 8: Configure launchd for Perpetual Operation
+
+Create the launchd plist for the main orchestrator:
+
+```bash
+cat > ~/Library/LaunchAgents/ai.maestro.maestro.plist << 'EOF'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.maestro.maestro</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>-c</string>
+        <string>source ~/.maestro-env && cd ~/maestro && ./scripts/orchestrator.sh</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>~/the-agent-repo/maestro/logs/orchestrator-stdout.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>~/the-agent-repo/maestro/logs/orchestrator-stderr.log</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+
+    <key>ProcessType</key>
+    <string>Background</string>
+</dict>
+</plist>
+EOF
+```
+
+Load the agent:
+
+```bash
+launchctl load ~/Library/LaunchAgents/ai.maestro.maestro.plist
+```
+
+Verify it is running:
+
+```bash
+launchctl list | grep maestro
+# Should show the process with a PID and exit status 0
+```
+
+## Step 9: Set Up Application Accounts
+
+### Slack
+
+1. Open Slack from Applications or install via `brew install --cask slack`.
+2. Sign in to the the company workspace.
+3. Ensure the agent's account is active and has access to all required channels (listed in `config/slack-channels.yaml` if present).
+4. Keep Slack running in the background. Configure it to launch at login: System Settings > General > Login Items > add Slack.
+
+### Gmail
+
+1. Open Safari and navigate to https://mail.google.com.
+2. Sign in as the-agent@the-company.
+3. Grant any necessary permissions for Google Calendar access.
+4. Keep the Gmail tab pinned in Safari.
+
+### WhatsApp
+
+1. Install WhatsApp: `brew install --cask whatsapp` or download from App Store.
+2. Link the device to the agent's WhatsApp account via QR code.
+3. Keep WhatsApp running in the background. Add to Login Items.
+
+## Step 10: Configure Desktop Control Permissions
+
+The the agent operating system uses desktop control (via macOS Accessibility and Screen Recording APIs) to interact with applications. These permissions must be granted manually.
+
+### Accessibility Permission
+
+1. Open System Settings > Privacy & Security > Accessibility.
+2. Click the lock icon and authenticate.
+3. Add the following applications:
+   - Terminal (or your preferred terminal emulator)
+   - Claude Code (if it appears as a separate application)
+   - Any automation scripts that need UI control
+
+### Screen Recording Permission
+
+1. Open System Settings > Privacy & Security > Screen Recording.
+2. Add the same applications as above.
+3. Restart the applications after granting permissions.
+
+### Automation Permission
+
+1. Open System Settings > Privacy & Security > Automation.
+2. Ensure Terminal has permission to control:
+   - Slack
+   - Safari
+   - WhatsApp
+   - System Events
+
+### Verify Permissions
+
+Run the desktop control verification script:
+
+```bash
+cd ~/maestro
+./scripts/verify-permissions.sh 2>/dev/null || echo "Verification script not yet created -- verify manually"
+```
+
+Manual verification:
+
+```bash
+# Test AppleScript accessibility
+osascript -e 'tell application "System Events" to get name of first process'
+```
+
+## Step 11: Verify All Workflows
+
+Run the workflow verification suite:
+
+```bash
+cd ~/maestro
+
+# Verify workflow YAML files are valid
+for f in workflows/daily/*.yaml workflows/weekly/*.yaml workflows/monthly/*.yaml workflows/quarterly/*.yaml; do
+  echo "Checking $f..."
+  yq eval '.' "$f" > /dev/null 2>&1 && echo "  OK" || echo "  INVALID"
+done
+
+# Verify output directories exist
+mkdir -p outputs/briefs/daily outputs/briefs/weekly outputs/memos/weekly outputs/memos/quarterly outputs/board/monthly outputs/followups/daily
+mkdir -p logs/daily
+
+# Verify config files are readable
+for f in config/*.yaml; do
+  echo "Checking $f..."
+  yq eval '.' "$f" > /dev/null 2>&1 && echo "  OK" || echo "  INVALID"
+done
+
+echo "Workflow verification complete."
+```
+
+## Step 12: Enable Monitoring
+
+### Log Monitoring
+
+Set up log rotation (see `docs/runbooks/perpetual-operations.md` for details):
+
+```bash
+cat > ~/Library/LaunchAgents/ai.maestro.maestro-logrotate.plist << 'EOF'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.maestro.maestro-logrotate</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>-c</string>
+        <string>cd ~/maestro && ./scripts/log-rotate.sh</string>
+    </array>
+    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key>
+        <integer>0</integer>
+        <key>Minute</key>
+        <integer>0</integer>
+    </dict>
+</dict>
+</plist>
+EOF
+
+launchctl load ~/Library/LaunchAgents/ai.maestro.maestro-logrotate.plist
+```
+
+### Health Check
+
+```bash
+# Quick system health check
+echo "=== the agent operating system Health Check ==="
+echo "launchd agent: $(launchctl list | grep maestro | awk '{print $1}')"
+echo "Disk space: $(df -h ~ | tail -1 | awk '{print $4}') free"
+echo "Memory: $(vm_stat | head -5)"
+echo "Log size: $(du -sh ~/maestro/logs/ 2>/dev/null | cut -f1)"
+echo "Last morning brief: $(ls -t ~/maestro/outputs/briefs/daily/*/ceo-morning-brief.md 2>/dev/null | head -1 || echo 'None yet')"
+echo "=============================="
+```
+
+---
+
+## Post-Bootstrap Checklist
+
+- [ ] Xcode command line tools installed
+- [ ] Homebrew installed and on PATH
+- [ ] Git, Node.js, Python, jq, yq installed
+- [ ] Claude Code CLI installed and verified
+- [ ] maestro repo cloned to ~/maestro
+- [ ] Environment variables configured in ~/.maestro-env
+- [ ] File permissions set (chmod 600 on secrets)
+- [ ] MCP servers installed and configured
+- [ ] launchd agent created and loaded
+- [ ] Slack signed in and added to Login Items
+- [ ] Gmail signed in via Safari
+- [ ] WhatsApp linked and added to Login Items
+- [ ] Accessibility permission granted
+- [ ] Screen Recording permission granted
+- [ ] Automation permission granted
+- [ ] All workflow YAML files validated
+- [ ] Output directories created
+- [ ] Log rotation configured
+- [ ] Health check runs cleanly
+- [ ] First morning brief generated successfully
+- [ ] (Optional) Voice/SMS configured -- see `docs/guides/voice-sms-setup.md`
+
+---
+
+## Optional: Voice & SMS Setup
+
+If this agent needs phone call or SMS capabilities (Slack huddle voice participation, inbound/outbound SMS via Twilio), follow the dedicated guide:
+
+**[Voice & SMS Setup Guide](../guides/voice-sms-setup.md)**
+
+This covers Twilio phone number purchase, inbound SMS webhook, outbound SMS, Slack huddle voice (Deepgram STT + ElevenLabs TTS), Cloudflare tunnel exposure, caller ID mapping, and launchd process management for the voice/SMS services.
+
+---
+
+Related documents:
+
+- `docs/runbooks/perpetual-operations.md` -- How the system runs continuously
+- `docs/runbooks/recovery-and-failover.md` -- Recovery procedures
+- `docs/guides/agent-persona-setup.md` -- Agent identity and configuration
+- `docs/guides/email-setup.md` -- Gmail IMAP and SMTP setup
+- `docs/guides/slack-setup.md` -- Slack app, tokens, and events
+- `docs/guides/whatsapp-setup.md` -- WhatsApp Business integration
+- `docs/guides/voice-sms-setup.md` -- Voice calls and SMS setup
+- `docs/guides/poller-daemon-setup.md` -- Event loop, daemon, triggers, watchdog
+- `docs/guides/outbound-governance-setup.md` -- Hooks, dedup, information barriers
+- `docs/guides/rag-context-setup.md` -- Search index and context retrieval
+- `docs/guides/pdf-generation-setup.md` -- Branded PDF documents
+- `docs/guides/media-generation-setup.md` -- AI-generated visual assets
+- `docs/workflows/executive-cadence.md` -- Full operating rhythm
+- `config/environment.yaml` -- Environment configuration reference