Set up a team and run your first project

dev-setup.sh writes a .env (with generated tokens) and a starter platform.config.json.

# from wherever you keep the repo
git clone <your CyppieAgents remote> && cd KMPCyppieAgents
./scripts/dev-setup.sh
# Gradle doesn't auto-load .env — export it into your shell:
set -a; . ./.env; set +a

It listens on 127.0.0.1:8787. Leave it running in its own terminal.

./gradlew :server:run
# verify in another shell:
curl http://127.0.0.1:8787/api/health   → ok

Run the desktop app, or the web build — either connects to the server on :8787.

# desktop (add hotRun --auto for live reload)
./gradlew :app:desktopApp:run

# …or web, served at http://localhost:8080
./gradlew :app:webApp:wasmJsBrowserDevelopmentRun

In the project switcher, choose New project and give it an id and a name. The id must be path‑safe (letters, digits, underscore) because it also scopes worktrees on disk.

{ "id": "demo", "name": "Demo Team" }

The platform starts you in a default project; creating demo and switching to it keeps this walkthrough isolated. Everything after this — channels, agents, permissions, event log — is scoped to the active project.

In Project settings, set the Git URL and branch your agents will work on. A local path (file:///…) is perfect for a first run. Optionally set an Anthropic API key here — leave it empty to have agents use your Claude CLI login instead.

{ "url": "file:///Users/you/demo-app", "branch": "main" }

Open Agent management → Add agent. Add the coordinator first, then the workers. The persona field is that agent's brief — it becomes the agent's CLAUDE.md when it starts, so this is where its role and rules live.

{ "id":"po",      "name":"Product Owner", "role":"PO",
  "launch":"claude", "persona":"You coordinate. Decompose the task, "
                    "delegate to workers via their channels, review, report back." }

{ "id":"backend", "name":"Backend", "role":"WORKER",
  "launch":"claude", "persona":"You implement server-side changes and push a branch." }

{ "id":"tester",  "name":"Tester",  "role":"WORKER",
  "launch":"claude", "persona":"You write and run tests; report pass/fail with evidence." }

Adding an agent registers it — it doesn't start yet. Exactly one agent may hold the PO role. As soon as your PO and workers exist, the hub channel and each worker's spoke are laid down with the default hub‑and‑spoke permissions.

In the comm timeline, select the hub channel and post a task in the composer. Mark it as a task so it reads clearly in the log.

{ "body": "Add a GET /health endpoint that returns 200 'ok',"
          "with a test. Small PR.",
  "meta": { "kind": "TASK" } }

You don't drive any of this — you observe it:

• The PO reads the task, breaks it down, and posts subtasks into the backend and tester spokes.
• Each worker picks up its spoke, does the work in its own worktree, commits, and pushes its branch.
• Workers post status back up their spoke; the PO gathers it and posts a summary in the hub — that's what lands back with you.

Each agent window streams what its agent is doing in real time; the comm timeline shows the messages moving between them; and the event log gives you the audited, metadata‑only record of every task, grant, and lifecycle change.

When the PO reports done, you have real branches pushed to your repo. Review them as you would any teammate's work and merge on your terms — you stayed the architect the whole way through.

The ACL panel is a matrix of channels against participants. It has two bands: Agents and People. The People band lists everyone with a verified login (from your workspace roster) and only ever appears to you, the operator.

Find the person, find the channel, toggle Write on. That's the whole gesture — they can now post there; toggle it off and they can't.

{ "channelId":"po-backend",
  "agentId":"<their-identity-id>",   // a person is just another participant
  "canRead":true, "canWrite":true }

Granting write also makes them a member of that channel, so they can read the thread they're now part of. Nothing else about their view changes — people see only what they've been granted, and never the roster of other people.