Roundtable

Roundtable coordinates multiple coding agents around one shared project state. Agents deliberate, claim resources, create proposals, review and vote, while a controlled transaction path governs changes to the authoritative repository.

This documentation describes the implementation in this repository. It distinguishes working behavior from planned surfaces, especially where an API or UI contract is broader than the currently implemented runtime.

Start here

• Quickstart initializes a local workspace and runs the Go coordinator.
• CLI Reference documents the commands and flags implemented by the executable.
• Configuration Reference describes every currently parsed key, default, and limitation of .roundtable/config.yaml.
• Architecture maps the Go runtime, standalone HTTP API, and web UI.

System areas

• Runtime and orchestration explains run lifecycle, cycles, turn scheduling, retry behavior, and convergence.
• Tasks and assignments documents local task storage, ordering, updates, and assignment behavior.
• MCP tools describes the agent-facing local tool boundary.
• Proposals and transactions explains how proposed changes are validated and applied.
• Security reviews covers automatic findings, manual review records, and the security gate used during application.
• Human approvals explains persisted decisions and the policy selection rules used during application.
• Tests and evidence documents command execution, captured logs, result status, and validation limits.
• HTTP API links to the OpenAPI contract and endpoint guide.
• Web UI records implemented routes separately from navigation concepts that are not yet implemented.
• Operations covers local deployment and runtime configuration.

Documentation conventions

“Implemented” means the behavior is present in this checkout; “contract” means an API/schema or design artifact specifies a behavior; “planned” means the implementation is not complete. CLI flags and configuration tables are maintained against source code. The generated endpoint guide is maintained against api/openapi.yaml.

Reference Directory

The left navigation is generated from one mkdocs.yml tree on every page. Its groups are Product, Getting Started, Runtime, Agent Interface, HTTP API, Web UI, and Operations. Runtime contains Governance and Database subgroups; HTTP API contains API Reference and Operations and Administration subgroups. The current page’s heading table of contents is separate and intentionally varies by page; on mobile, open the navigation drawer to reach the shared groups.

Product and Startup

Reference	Use it for
Project overview	Repository purpose, implementation scope, and entry points.
Product model	Shared-state concepts and intended coordination model.
Architecture	Process boundaries and which component owns each operation.
Agent protocol	Participation and governed repository-work expectations.
Quickstart	Local initialization and first execution.
CLI	Command syntax, flags, defaults, and output behavior.
Runtime configuration	Parsed YAML settings; not HTTP configuration revisions or browser build variables.

Runtime and Agent Interface

Reference	Use it for
Orchestration	Turns, pressing turn requests, run lifecycle, scheduling, and HTTP run-control boundaries.
Tasks	Task metadata, assignments, and ordering.
Symbols	Resource identities, indexing coverage, and HTTP repository-entity limitations.
Policies	Markdown policy parsing, runtime gates, HTTP policy administration, evaluation, votes, and consensus differences.
Claims	Leases, overlap, ownership, HTTP acquisition, and contention resolution.
Transactions	Proposals, patch previews, validation/application, phase records, and recovery/compensation limitations.
Security reviews	Heuristics, persisted review decisions, and application gates.
Human approvals	Local and HTTP approval fields, transitions, selection, and trust boundaries.
Tests and evidence	Executed commands, captured results, and HTTP validation-stage semantics.
Sessions and resume	Session lifecycle, external resume metadata, and HTTP observability scopes.
Adapters	Provider declarations, executable probes, enablement, and diagnostics.
TUI and watch	Terminal display and refresh behavior.
Persistence overview	SQLite operation, migrations, and table roles.
Schema detail	Final/control-plane columns, constraints, and migration-specific differences.
Memory Oracle	Memory creation/search, revisions, provenance, merge, and lifecycle controls.
MCP tools	Advertised tool inputs and implemented local handlers.

HTTP API and Browser

Reference	Use it for
API overview	Server flags/environment, authentication defects and limits, CORS, metrics, health, repository/branch controls, deliberations, events, logs, audit, analytics, and dashboard projections.
Endpoint guide	Generated method/path inventory, declared permissions, and schema links. Permission labels are contract metadata, not independent enforcement.
Schema reference	Generated component properties, required flags, and declared response shapes; not runtime conformance proof.
Error and retry semantics	JSON decoding, attribution, actual authorization checks, idempotency scope, and recovery after ambiguous responses.
Pagination and search	Endpoint-specific cursor formats, ordering, filters, and consistency limits.
Workspace settings	Defaults, revisions, confirmation/version handling, and settings not wired into running components.
Notifications	Recipient selection, unread/actionable counts, acknowledgment, and broadcast behavior.
Maintenance	Global database backup, integrity, checkpoint, and destructive notification retention.
Web UI	Implemented browser routes, configuration, client behavior, and unfinished navigation surfaces.

Operations and Evidence

Reference	Use it for
Deployment	Local/process deployment, GitHub Pages preparation/navigation checks, and verification scopes.
Troubleshooting	Diagnosis and recovery without assuming mutation rollback.
Resume briefing example	Example agent context, not authoritative state or a guaranteed exact generated format.

Read behavioral references alongside generated contracts when calling an endpoint: implementation limitations can differ from declared fields and permission labels. A successful documentation build proves rendering/link checks, not live API correctness, safe repository mutation, exhaustive coverage, or publication of the current checkout. The source-grounded coverage audit remains ongoing.