Compose a PRView SourceOpen Issue

Synced from Hive. This page is pulled from hivecommons/hive@v5 during the docs build. Edit the canonical source in the Hive repository.

Documentation map

Use this map when you already know the area you need and want the full Hive documentation catalog.

New to Hive? Use the introduction to choose hosting, then Getting started for your first session. This catalog is a reference, not a reading order.

Descriptions below name the task; implementation keys and incident history belong in the destination. Operator, developer, design/proposal, and historical labels distinguish pages that are not installation steps.

Documentation for the current Hive line (branch v5; the code and docs live under the src/ directory). The v2 branch was retired in August 2026 — operators upgrading a v2 deployment should start with the v2 → v4 migration guide, and v4 operators should use the v4 → v5 migration guide.

Operations

First installation

  • Hosted Hive Hub onboarding — signing in at https://hive.hivecommons.dev, requesting a hosted hive, installing the GitHub App, configuring model gateways and Copilot login, reading /fleet, and fixing common setup problems.
  • Docker Compose quick start — default standalone installation, prerequisites, and verification.
  • Podman quick start — standalone Quadlet/systemd installation, with rootless/rootful prerequisites.
  • Kubernetes deployment — standalone cluster installation, storage, authentication, and dashboard access. Related: health checks.
  • Manual provisioning — Operator: choose standalone Kubernetes, hub-reachable provisioning, or heartbeat-only provisioning.

Configuration and day-to-day control

  • Self-hosted hub deployment — HIVE_MODE=hub, hub storage, heartbeat secrets, and SaaS spoke registration.
  • CAP_NET_ADMIN and self-hosted spokes — Operator: diagnose fail-closed startup, grant required network capabilities, or understand the explicit advisory-only opt-out.
  • Config layering — how ConfigMap seed, PVC dashboard overlay, and runtime config interact.
  • Operator reference — top-level config blocks, hive flags/env, GitHub token scopes, and image provenance.
  • Running a hive at ACMM Level 6 — preparation, GitHub/coverage/knowledge/Hive/ClankeR settings, weekly routine, and incident recovery.
  • Maintainer commands — slash-command reference for /hive approve, /hive decision, /hive help, /fixed, /reopen, and label/assignment helpers.
  • Token mint — the opt-in mint: block (pkg/mint): what a minted token grants, key lifecycle, and the trust boundary an operator must get right before enabling it. Companion to ADR-0007.
  • Changelog — recent user-visible changes and release notes.
  • Work-source terminology — glossary and audit notes for keeping user-facing copy neutral across GitHub, GitLab, Gitea, Linear, Jira, and future work sources.

Releases and release-maintainer policy

  • Release channels — stable/candidate/edge moving image tags, per-line channel ownership (v5 → candidate/latest, v6 → edge, v4 → none), switching a hive to a channel, the version pill, and the timeline for when a hive follows stable after the tag moves.
  • Digest-verifiable rollback — Operator: pin all three images to prior builds, stop conflicting automation, and verify running digests.
  • Outcome benchmarks — compare change quality, review, timing, and cost from stored evidence; includes monthly reports and generated README cards.
  • v5 GA readiness bar — measurable release-train, migration, safety, and governance criteria that must be evidenced before v5 can be promoted beyond the active-development edge channel.
  • v5 GA candidate week sequencing — dependency-ordered plan for the remaining human-gated GA-bar steps: candidate-SHA designation, candidate-pinned measurements, the two bound exercises, and the v4 freeze evaluation.
  • Stable soak and promotion policy (v5 line) — Release maintainer: normal promotion gates, emergency checklist, closure evidence, and per-image rollback ledger.
  • HiveCommons migration tracker — phased org/package migration status, operator promises, and sequenced closeout checklist.
  • v4 → v5 forward-port sync policy — proposed cadence, ownership, merge-commit top-up procedure, and the PR/review contract for keeping v5 topped up with v4; protects the v5 GA bar from unbounded drift.
  • v4 feature-freeze execution runbook — Release maintainer / migration record: declare the freeze, redirect work, and carry eligible fixes forward.
  • v5 migration — operator announcement — draft, do not publish until #7721 Phase 0 completes: the migration-week announcement text (channel table before/after, per-selection operator actions, security-fix policy while stable lags, rollback, key dates) and the marshal’s publication checklist.
  • dibs domain cutover — staged operator sequence for moving dibs to dibs.hivecommons.dev, including DNS, Let’s Encrypt quota hold, Certificate/Ingress manifests, redirect verification, and rollback.
  • Serving spokes from the fleet wildcard certificate — how to point a cluster’s provisioned spokes at the wildcard instead of one certificate per hive, the two cluster prerequisites that must hold first, and which hosts a wildcard cannot cover.
  • Tagged releases — Release maintainer: trigger/version rules, manual recovery, channel relationship, and release SBOM artifacts.
  • Release sentinel — Opt-in; off by default: bounded repair for failing release CI, human escalation, and separately opted-in retagging.
  • Dashboard-triggered standalone upgrades — the dashboard upgrade button for standalone (Compose/Podman-Quadlet) hives: the HIVE_DEPLOYMENT_RUNTIME/HIVE_DEPLOYMENT_PODMAN_MODE runtime contract, the closed host-side helper (hive-dashboard-upgrade-helper.sh), and why an unproven runtime deliberately hides the button.

Dashboards and integration reference

  • Work source providers — Developer: implement an adapter. To configure an existing tracker, use Work sources.
  • Forges: GitLab, Gitea and Forgejo — project.forge, the gitlab:/gitea: keys, which pkg/forge operations each adapter supports, which governor writes already use them, and how the dashboard shows the forge.
  • Hive Labels and Control Signals — authoritative operator reference for labels, holds, approvals, contributor skip labels, planning labels, and dashboard bands. The old Hive issue labels page redirects here.
  • GitHub webhooks: cadence, patch and reconcile — configure event-driven updates, understand snapshot accuracy, and diagnose fallback to polling.
  • Spoke dashboard — the static dashboard FAQ panel contract: not ACMM-gated, no JS/fetch, grouped L1-L6/runs/contributors/claims/cost help, and guarded config-key references.
  • Dashboard sections explained — plain-language operator help for every dashboard section: what it shows, how its numbers are worked out, what to do about them, when it appears, and which settings change it. The ? mark on each section title opens its entry.
  • Dashboard settings explained — one entry per Settings tab: what it controls and which guide explains it. The ? mark next to each setting opens its guide or this page.
  • Dashboard feedback — reporting bugs and requesting features from the spoke dashboard, including diagnostics, screenshot handling, hub relay, user-auth, and fallback issue paths.
  • Dashboard source layout — static/index.html is generated from per-area CSS/JS/HTML sources in static-src/ via make dashboard-gen; how to edit, add an area, and resolve merge conflicts.
  • Dashboard design system — shared token catalogue, component variants, migration rules, ratchet plan, and #8536 theme override contract for spoke, contributor, and hub dashboard surfaces.
  • Dashboard glossary and sidebar IA — the operator-facing names used by the dashboard and the ADR-0018 sidebar information architecture.
  • The auto-update Compose profile — what unattended Watchtower updates cost you, what the Docker socket proxy does and does not fix, and why Kubernetes should not use this profile at all.
  • Environment variable reference — centralized list of runtime, deployment, hub, backup, and contributor environment variables.

Recovery, moves, and fleet health

  • DiskPressure recovery runbook — diagnose storage eviction, recover safely, and expand or migrate volumes.
  • Agent backend-auth failure recovery runbook — identify affected agents, re-authenticate the backend, and clear recovered fleet reports.
  • Troubleshooting — container logs, config validation, agent tmux sessions, dashboard auth, GitHub credential checks, and GitHub App workflow-permission push rejections.
  • Admin MCP reference (v6) — diagnostic reads for logs, startup output, request logs, agent terminals and kick logs, and crash/restart/memory evidence via the admin MCP: log_sources, log_read and its diagnostic read companions, and what still needs a host shell.
  • Community and support — Discord, contributor portal, issue tracker, and where to ask Hive Commons questions.
  • Integration guide — third-party extension surfaces for work source providers, ClankeR/Flue-style external execution, and Spektacular-backed Project Inception.
  • Cross-cluster migration — the manual procedure for moving a hive between clusters.
  • Self-hosted Kubernetes cluster move — moving a self-hosted (non-hub) Kubernetes hive between clusters: which PVC/Secret/ConfigMap paths hold identity and state, a generic kubectl-based PVC copy, target prerequisites, and verification.
  • Hub-registered hive cutover — cross-cutting rules for any hub-registered hive’s move: what identity is, how the hub reads heartbeat/dashboard_url, why source and target must never run concurrently, the required cutover order, and rollback.
  • Moving a Hive between hosts, same runtime — Documented, not executed: preserve identity/state on Compose or Quadlet moves; stop the source before starting the target.
  • Cross-runtime moves — Podman → Docker (the reverse of backup-restore.md’s executed Docker → Podman migration), and Compose/Quadlet ↔ Kubernetes: volume ↔ PVC, secrets ↔ Kubernetes Secrets, and which host-bound settings must change. Documented, not executed.
  • v2 → v4 migration — upgrading a v2 deployment: the config is compatible unmodified, and what actually changes is the image tag, the published 7681 port, and the Compose/Kubernetes security settings.
  • v4 → v5 migration — upgrading a v4 deployment before the 2026-12-21 EOL: channel/tag changes, additive config deltas, Kubernetes/Compose/Podman rollout steps, verification, and digest rollback.
  • Major-version upgrade guide — preparing for v4 → v5 and future major-version boundaries.
  • Dashboard route and health checks — dashboard-route-rbac.yaml, route_exists, listener probes, and alert behavior.
  • Fleet health: the verdict and remediation hints — read green/amber/red/unknown health states and choose the matching recovery action.
  • Fleet drift signals — interpret deviation badges and identify whether the owner or hub operator must act.
  • Fleet self-reporting (governor.fleet_report) — Off by default: preview or opt in to reports about failures caused by Hive. Explains sent data, duplicate-report handling, and recovery records.
  • Push-reported cluster node health — how spokes on clusters the hub cannot kubectl push node health in their heartbeat (hub.cluster_id / HIVE_CLUSTER_ID, the heartbeat node-health block, and how the hub merges it into cluster views).
  • Agent self-healing watchdog — Observe mode by default: diagnose stalled/crashing agents and review proposed restarts before enabling repair.
  • Audit log format — parse action records, actors, targets, and rotation limits; lookback varies with log volume.
  • Per-repo agent pause — pause one repository, understand enforcement, and see what reads/operator actions remain allowed.
  • Token-access audit log — Owner reference: inspect credential-access records and understand retention and coverage gaps.
  • Per-repo agents — scope specialists to repositories, preserve operator-owned scopes, and understand enforcement limits.

Agent writes and network reference

  • hive-open-pr — how agents open pull requests as the App bot instead of via gh pr create: the flags, the UID-ownership anchor that makes the request forge-resistant, and the asynchronous contract (exit 0 means requested, not opened).
  • hive-merge — how agents merge pull requests as the App bot instead of the GitHub MCP merge_pull_request tool: the flags, the F4 target-binding (pinned head SHA + governor merge-eligible list), and the retry/re-engagement behavior when required checks are still red.
  • hive-open-issue — Agent/developer reference: request issue creation, comments, or claims through the App bot, with deduplication and retries.
  • Review-bot threads on hive-mediated PRs — route bot feedback back to the authoring agent while protecting human review threads.
  • Network and port requirements — inbound ports, proxy paths, egress, and firewall guidance.
  • TLS, HTTPS, and certificates — termination patterns and certificate ownership.
  • Security notes — log scrubbing and secret redaction guarantees/limits.
  • Token collection and usage tracking — session JSONL, /api/cost, and hub usage rollups.
  • Notifications — ntfy, Slack, and Discord alert channels, plus the two-way Discord bot.
  • State-triggered hooks — declarative transition → action rules, the transition catalog, the vetted action set, and the security model (RFC #4001).
  • CEL-based agent triggers — the triggers: config key: declarative CEL rules that kick an agent on a normalized source-control event, additive to built-in label/governor triggering, the event.* field reference, and the fail-closed compile/runtime contract.

Long-running work and external execution

  • Long-running runs — how a run starts, including default-off triage admission and inception completion admitting an explicit GitHub issue into the first spec lease.
  • Spektacular (Spek) stage runner — Operator; opt-in: configure and monitor Hive’s spec → plan → implement stages. Artifact design: run artifacts.
  • ClankeR and Flue-style external execution — how the contributor relay and pkg/extwork let an external engine receive bounded work, report status, and return digest-verified receipts without repository credentials.
  • Spektacular and Project Inception — Developer integration: CLI status, final-plan import, and inception admission; not the operator stage-runner setup above.
  • vibe-kanban mirror and dispatch — default-off side-car that mirrors one repository’s admitted hive queue onto a local vibe-kanban board, records board pick-ups as shadow executions, and documents the opt-in pkg/extwork/vibekanban report-only workspace dispatch adapter.
  • Audit campaign — Owner-triggered; publication off by default: run report-only inspections with credential guards, stage receipts, and explicit publication gates.
  • Public snapshots — read-only /snapshot, custom CSS, and frame-ancestor sharing.
  • hivectl — command-line client for the dashboard API, including hivectl tui, the full-screen terminal dashboard: keybindings, pane cadence, and v1 boundaries. See the design record for the reasoning behind it.
  • bd beads CLI — work-ledger and knowledge command reference for operators and contributors.
  • crux CLI — run, list, tail, kick and stop agents through crux.Runtime with no governor or dashboard; definition formats, the control socket served by crux run, and why the runtime being in-process shapes it.
  • crux serve: the runtime over a local API — Developer: operate the runtime server through its authenticated API, event stream, CLI, or Go client.
  • Publishing Crux — how hivecommons/crux is produced from src/crux (plain copy, module path rewritten, fast-forward commits), what is preserved there, the CRUX_SYNC_TOKEN credential, manual sync and how a crux/vX.Y.Z tag becomes a release.

Backup and API reference

  • Backup and restore — choose runtime-specific backups, encryption, safe restoration, and migration. Covers identity checks and rootless ownership traps.
  • Hub disaster recovery — the hub-level runbook that goes beyond per-hive backup: hub backup and key escrow, spoke fleet recovery, Slack blast, and the full rebuild-from-zero procedure after a catastrophic loss.
  • Deployment helper scripts — the all-in-one LXC setup, Proxmox LXC, and blue-green Compose helpers. All are Docker-only; the page states each script’s runtime scope and where a Podman operator should go instead.
  • Streaming the Activity Monitor — put the dashboard’s stage tracker on an unattended 24/7 Twitch stream: Twitch-side setup, the hive-stream image and Kustomize overlay, verification and troubleshooting.
  • bin/ pipeline script index — map of the deterministic pipeline and operational scripts, grouped by function.
  • Dashboard API reference — pragmatic route index for dashboard and hub endpoints; one page per area under api-reference/ (health, auth, configuration, agents, ACMM, cost, knowledge, contribute, nous, inception, beads, misc, hub SaaS, hub server).
  • Dashboard OpenAPI spec — machine-readable REST API reference for integrations.
  • ioscan status — the untrusted-input scanner/canary feature (live and default-on in v4).
  • Deployment scripts — inventory of deployment helpers, including dashboard TTY panes and hive-panes.

Contributors and access

Configuration and agents

  • Agent configuration — agent fields, methods, models, pins, cadences, caveman mode, ACMM packs, and live-linked definition_source (with its seed-only trust model).
  • Formal verification — the optional L5/L6 quality.formal capability for agent-authored Spin/Promela models, reporting-only CI, and deduplicated counterexample issues.
  • Advisory digest — what the digest shows (max_findings, show_all), how stale findings are marked unverified, and which positive signals retire findings.
  • Advisory digest staleness — when the hub raises the stale-advisory pill and alert, the gates that deliberately suppress it (undelivered App, App cannot write, all agents quiet), and the admin diagnostics that measure hidden staleness.
  • Guide flow-health diagnosis — the HIVE_FLOW: kick signal and its field contract (surge, mttm_sample, oldest_actionable, …), the surge-coach lens that prioritizes a documentation finding under sustained congestion, and the bucketed finding/follow-up policy, without a new agent, timer, or permission grant.
  • Governor mode thresholds — how idle/quiet/busy/surge thresholds scale with repo count, the threshold_scaling curves, and when explicit thresholds win.
  • Large-spoke scale envelope — understand tested backlog scale, prompt limits, caching, and configurable versus fixed caps.
  • Supervisor agent — supervisor policy modes, bead roles, and when to enable the orchestration lane.
  • Telemetry agent — the L5/L6-only opt-in observability agent, ACMM level gating, and the project_observability opt-in flow.
  • NPS feedback prompt - the dashboard’s opt-in NPS question: what is collected (no user identity), how it reaches the hub (directly, or through the opt-in relay for standalone hives), why only hub admins can read it, and the hub.nps_enabled / HIVE_NPS_ENABLED switch.
  • Operations agent — the L5/L6-only opt-in operational-readiness agent (health checks, SLOs, runbooks), ACMM level gating, and the project_observability opt-in flow.
  • Custom dashboard stylesheets — operator-supplied CSS for the dashboard and public snapshot.
  • Branding a hive — persistent per-deployment name, mark, and colours via <data>/branding/branding.json and custom.css (HIVE_BRANDING_JSON/HIVE_BRANDING_CSS); distinct from the per-request ?style= stylesheets above.
  • Portable AgentDefinition format — standalone YAML schema for importing/exporting agent definitions.
  • Knowledge connectors — Owner configuration: connect, validate, and sync external document/wiki sources; includes scope and API reference.
  • Knowledge curator — configure fact extraction, sources, vaults, document imports, code maps, and retention.
  • Knowledge confidence scoring — interpret confidence badges and score explanations.
  • Knowledge lifecycle states — approve, deprecate, or supersede facts and keep stale knowledge out of prompts.
  • Scoped knowledge table of contents — Developer reference: list and read knowledge through API/MCP.
  • Public knowledge MCP endpoint — the owner-switched, read-only POST /mcp/knowledge surface that lets any external agent (Goose, Claude, Copilot) read a hive’s operational knowledge without a session; what is and is not exposed, and client configuration.
  • Skill registry — opt agents into reusable skills; covers registry/repository lookup, live reload, and whole-skill size limits.
  • House style — the short how-to-change section that opens every kick; repo HIVE_STYLE.md > project.style > built-in, size-capped and ioscan-checked.
  • AGENTS.md repo instructions — add repository instructions and skills to kicks; requires a configured local checkout.
  • Agent peer-awareness logging (pluk) — pluk log format, hive-panes, availability, and retention.
  • Experiment Lab (Nous) — experiment lifecycle, dashboard/API configuration, fast-fail bounds, and the gate-decision flow. No nous: block in hive.yaml.
  • Hive-self background experiments (Nous) — background-only self-improvement experiment mode, outcome questions (including user satisfaction), cohorts, guardrails, and auto-revert. Hidden from spoke dashboards and Experiment Lab.
  • GitHub write surface — inventory agent and system writes, their audit coverage, and opt-in per-lane restrictions.
  • Compact GitHub CLI reads (hive-gh) and one-line denials — Agent/developer reference: compact output fields, full-read escape hatch, and denial codes.
  • GitHub App setup — the Forge App on GitHub and GitHub Enterprise: app creation, permissions, Setup URL, and /gh-setup.
  • Forge setup: GitLab, Gitea, and Forgejo — Adapter/reference only: explains configured adapter surfaces and why a complete hive still requires GitHub.
  • ACMM policy matrix — capability levels and policy modes.
  • ACMM level-up advisor — the advisory-only pkg/acmmadvisor computation behind GET /api/acmm-recommendation: the signals it measures, per-level thresholds, and why it never changes the applied level.
  • ACMM waivers — record criteria satisfied outside the repo; a waiver can restore green status, never advance a level.
  • Inception — operator guide to the L1 brainstorm/inception workflow: phases, API, and template variables.
  • Planning intelligence — how a large GitHub issue becomes an epic the architect lane decomposes into child beads, the human plan-review gate that withholds those children until approved, and stall-replan.
  • Review swarm — the five review perspectives, the verdict collector and its report contract, and the opt-in merge-gate integration and bounded auto-fix cycle for review findings.
  • Swarm mode — focusing the hive on one repository for a bounded window: Discord announcements, theming (swarm: config, HIVE_SWARM_EVENT_NAME / HIVE_SWARM_CALL_TO_ARMS), the /api/leaderboard/swarm endpoint and scoring.
  • Review evidence bundle — the per-PR evidence bundle schema (v1), canonical hash, Ed25519 signing, offline verification, and retention design.
  • Evidence reporting — the guarded control-arm (control_window: on|off) evidence report: per-repository outcome comparison, the minimum-denominator rule, and why it is reporting groundwork rather than an enabled experiment.
  • SOC 2 control mapping (not a compliance claim) — maps common auditor change-management questions to bundle fields, with sample policy language and the gaps Hive does not cover.
  • Duplicate PR sweep — Opt-in; recommendations only: identify overlapping PRs and suggest which to keep. Never closes them automatically.
  • Upstream watch — the opt-in upstream_watch block (per-repo upstream or the GitHub fork parent, sources, pr_labels, max_issues_per_run, label) and the poll loop it drives: classification, fork applicability, labelled upstream: issues with a hidden upstream-ref marker, dedupe and dismissal, and the /data/upstream-watch.json state file.
  • Hold-gated review queue triage — the triage-class policy for the human review queue (T0 fixes, T1 behavior-adjacent, T2 additive), the shipped review_class presentational sort in last-actionable.json and the dashboard PR list, and the open mechanism options awaiting maintainer decisions (#6183).
  • Retro lane — the opt-in (retro.enabled) post-completion pass that reconstructs a record for each closed bead and flags patterns such as excessive fix attempts or kicks; deterministic by default, with LLM analysis separately opt-in.
  • Work sources — governor.work_source: the four type options (github default, github_projects, linear, jira), Jira Cloud/Data Center deployment modes, config fields, required credentials, and priority/hold-label mapping per source.
  • Linear agent integration — joining a Linear workspace as a first-class agent member: webhook verification, the 10-second session acknowledgement, which hive agent takes sessions, and narrating completion back as agent activities.
  • Lite enrollment — the zero-repo-secret on-ramp: hivectl enroll OWNER/REPO adds a repo to a spoke’s project.repos, with prerequisites and the hosted lite-spoke path.
  • ACMM policy fragments — per-level ACMM policy references.
  • Sandbox isolation and agent guardrails — isolation layers and operator guardrail notes.
  • Per-agent gh restrictions — file-based wrapper denials in /etc/hive/restrictions/.
  • Podman rootless CI — rootless Podman contract for contribute-hive.
  • Podman Quadlet .kube compatibility spike — why the standalone Kubernetes overlay is not a safe direct source for Podman units.
  • Podman ownership and cleanup contract — the labels that mark a resource Hive-owned and the guard that keeps Podman/Buildah cleanup from reaching the operator’s other containers, Distroboxes, and images.
  • Podman preflight: SELinux, mounts, secrets, and ports — read-only diagnostics for SELinux state and mount labeling, configuration/secrets readability, and published host-port availability, with remediation that never disables SELinux or widens a secret.
  • Podman preflight: subordinate IDs, graphroot, and networking — read-only diagnostics for rootless subordinate UID/GID delegation, unsupported (NFS and other distributed) container storage, and the rootless network backend/helper, with remediation that never edits /etc/subuid or /etc/subgid.
  • CLI backend setup — setup notes for Claude, Copilot, Goose, Bob, Pi, Codex, and Aider.
  • Backend support tiers and acceptance bar — Developer policy: qualify a CLI backend’s confinement, authentication, unattended operation, and required evidence.
  • Gap analysis: Claude Managed Agents — Design/evaluation: compare hosted execution with the acceptance bar; direct GitHub egress limits authority to advisory.
  • Gap analysis: OpenAI Agents API — Design/evaluation: assess hosted tools, metering, and write paths outside Hive’s proxy.
  • Omnigent CLI contract and policy composition — Experimental/unconfined backend reference: launch contract, credentials, safety flags, refusal gate, and policy composition.
  • Inference backends — vLLM, llm-d, LiteLLM, and Model Gateway troubleshooting.
  • apiproxy — Anthropic-compatible proxy logging and deployment notes.
  • Outreach anti-spam ruleset — the deduplication and anti-spam rules the outreach agent operates under across awesome lists, project issues, directories, and community threads.
  • v1 to v2 migration — historical. Both ends of this migration are retired; v2 was retired in August 2026. Kept for operators still on v1, who should read it alongside v2 → v4 migration above. New deployments do not need it.

Architecture and design

  • What Hive is — product fit, hosting choices, concepts, permission levels, related projects, and community entry points.
  • Architecture — process model, governor loop, guardrails, hub/spoke, and walkthrough.
  • Automatic repo ACMM onboarding reconciler — proposed design for per-repo ACMM targets, gap-to-work reconciliation, human hand-off, waivers, and anti-gaming controls (RFC #6235).
  • Hive federation design — the multi-hive registry: live /api/hives endpoints, project onboarding, contributor flow across hubs, and what remains future design work.
  • Public roadmap — available foundations, current/future direction, release-line status, completed work, and dated decision evidence. Not a delivery promise.
  • Integrations — one page of logos and status (Supported / Opt-in / Planned) for agent backends, work sources, forges, sandboxes and upstream projects.
  • Landscape and positioning — how Hive’s operations-plane design compares to nearby agentic orchestration tools, with public references per project. Explicitly time-sensitive; check the conducted date in its header before quoting product details.
  • CNCF sandbox onboarding status — repo-local map of the onboarding tracker and repository evidence (LICENSE, governance, security, OWNERS, DCO).
  • CNCF reference architecture — CNCF submission/reference template.
  • Podman CI runner map — measured hosted-runner capabilities and which Podman lane goes where; SELinux is the only lane needing non-hosted infrastructure.
  • CI runner labels — how runs-on: picks the self-hosted fleet, why a fork must degrade to a GitHub-hosted runner, and the one variable hivecommons sets.
  • Gate-integrity invariants for agent lanes — proposed write-gate rules for agent lanes: no history rewrites on branches a lane did not create, no sign-off on other authors’ commits, and hold-gated demotion for gate manipulation.
  • Crux: the agent runtime boundary — Design record: runtime separation, module boundary, staged rollout, and naming decision.
  • Design documents — browse records labelled shipped, partly shipped, design-only, or historical; proposals are not current behavior.
  • Discord reaction-consensus issue promotion — proposed design for turning Discord reaction consensus into an audited Hive label write that composes with project.issue_filter.require_labels (RFC #6239).
  • GitHub @-mention triggers — v6 development branch only: summon agents from issues/PRs with the existing permission guards; not a v5 feature.
  • Podman Compose-provider selection spike — why podman compose must name its provider explicitly, and which provider needs no Docker tooling.
  • Sourcing token metering from ccusage behind a tokens.Source seam — proposed design for ccusage-backed token metering with attribution preservation, Bob fallback, and cutover diagnostics (RFC #6234).
  • Trajectory review — trajectory safety lane and review signals.
  • Central stage engine implementation plan — companion to ADR-0025: the PR-by-PR plan that landed pkg/stageengine as the single writer of stage/* labels.
  • Podman Quadlet .container/.pod spike — feasibility result for explicit Quadlet units: readiness via Notify=healthy, the startup-timeout trap, and what the generator does not validate.

Historical/design notes

Some documents describe planned or design-only work rather than live features. Those pages are marked at the top, for example Credly badges. The longer-form design records under design/ are a whole directory of these: each entry in that index carries a status, because those pages are the reference record of a decision and are deliberately not rewritten as later stages ship.

Security (v5)