多LLM协作

Install

The CLI is published on npm. Install it globally with either package manager:

```bash npm install -g gojaja

Step 3 — Install the runtime

AGENTS.md is the canonical runtime file. As of 2026 it's a cross-tool standard — read by Codex, Cursor, Copilot, Windsurf, Zed, and more — so one file covers almost everything:

```bash

Uninstall everything (`gojaja reset`)

When you're done with a project (or you want to tear down the coordination layer and start fresh), run:

```bash

Quickstart — drive everything from `gojaja watch` (recommended)

The dashboard handles every setup step you used to need a terminal for. One command, then point and click. No init / role create / prompt --write / activate typed by hand unless you want to.

cd /path/to/your-project
gojaja watch                    # serves http://127.0.0.1:7421 and opens your browser

(Install the CLI first if needed — see Install above.)

A browser tab opens automatically. Walk through it:

1. Initialise — if .gojaja/ is missing the dashboard shows a single full-screen Initialise this project button. Click it. (For non-git roots or repos with uncommitted changes the button explains the trade-off and asks for a one-click confirmation — same gate as the CLI's [y/N] prompt, just rendered in HTML.)
2. Create roles — switch to the Setup tab → Create role card. Fill id / title / owns (and reportsTo / mustNotEdit if you need them), click Create role. Repeat for each role on your team (PM, Backend, TL, ...).
3. Fill each role contract — open .gojaja/roles/<id>.md in your editor and replace the TBD placeholders (Role description + Responsibilities). The dashboard's Activate step refuses to issue a snippet for a role whose markdown is still TBD, so this step is gating-by-design rather than nagware.
4. Install the runtime — Setup tab → Install runtime files card. Pick the target host (agents covers Cursor / Codex / Copilot / Windsurf / Zed; pick claude if you use Claude Code). Click Install. The card tells you to restart any open agent window so the new rule takes effect.
5. Activate each agent window — Setup tab → Activate card. Pick role + target, click Generate snippet, then Copy. Open the agent window for that role (Cursor tab / Claude Code window / Codex CLI shell) and paste. Repeat once per window you want to staff.
6. From now on you mostly chat with the agents. The Dashboard tab shows live state across every window (sessions, task board, RFCs, activity feed, plus a red stalled flag for any role that forgot to gojaja wait after ack); the Actions tab lets you push a report --to <role> / open an RFC / create a task without leaving the browser, all recorded in the audit log as from: SYSTEM.

The Setup and Actions tabs only appear when gojaja watch is bound to loopback (default 127.0.0.1). When you share the dashboard over a LAN with --host 0.0.0.0, both write tabs hide and the dashboard goes read-only — anyone on the network can spectate, no one can push directives at the team. Ctrl-C in the terminal stops the server.

If you would rather drive the same flow from a shell — to script onboarding, learn the protocol, or just because you prefer the CLI — keep reading; the next section walks through the same four steps as terminal commands.

---

after you've verified your team can still work, optionally:

gojaja migrate --execute --cleanup # remove the v2 source files ```

The walker is idempotent and keeps the v2 source files as a safety net by default. See RFC-0001 for the design rationale and CHANGELOG PR9.3 for the migration details.

Bare-human commands now require an explicit --as-system flag where they previously defaulted to actor=SYSTEM on a missing GOJAJA_SESSION. This affects gojaja report --to, task new, task assign, rfc new, rfc comment, state edit, role create, role delete. Agents working through a claimed session are unaffected — --as-system is the project-owner flag.

---

Brainstorm (RFC without `--options`)

When three or more roles need to weigh in on a question with no concrete options yet, open an RFC without --options:

```bash gojaja rfc new q3-priorities \ --title "Q3 priorities — what should we be optimising for?" \ --deciders TL --voters PM,Backend,Frontend,DevOps \ --description "Performance, growth, or reliability? Drop ideas, risks, and follow-ups."

Voters post freely — no option required

gojaja rfc comment RFC-0001 --rationale "Idea: focus on perf; we lost two churned accounts to latency." gojaja rfc comment RFC-0001 --rationale "Risk: aborting feature X mid-flight upsets enterprise tier." --reply-to <prev-id>

Once a concrete choice emerges, anyone can lift it into the option list

gojaja rfc add-option RFC-0001 --option perf:'Q3 = perf-only' --rationale "From discussion above."

Or, after add-option, close with a pick (normal RFC flow):

gojaja rfc decide RFC-0001 --option perf --rationale "Going with perf-only." ```

---

Anyone with a session can add an option mid-discussion if the

projects need (covers Cursor, Codex, and most CLI agents).

gojaja prompt --target agents --write

The **only** common exception is **Claude Code**, which doesn't read `AGENTS.md` natively yet (it reads `CLAUDE.md`). If you use Claude Code, use the `claude` target — it writes `AGENTS.md` (canonical) **plus** a one-line `CLAUDE.md` that just imports it, so there's still a single source of truth:

With a parent epic, reference doc, and a hard deliverable:

gojaja task new --title "Build /login endpoint" --owner Backend --priority P1 \ --parent T-0010 \ --tag auth \ --asset 'file:docs/specs/auth.md::Auth spec' \ --asset 'url:https://figma.com/file/xxx::Login UI design' \ --deliverable 'file:apps/api/auth/login.ts::Implementation' \ --deliverable 'file:docs/api/login.md::API doc'

gojaja report --to TL --message "Auth scope confirmed. Backend is unblocked."

The deliverable lines mean: Backend cannot mark T-0011 Done until
both files exist on disk. If a reviewer waives a deliverable, Backend
runs `gojaja task status T-0011 Done --force-incomplete` and the
bypass lands in the event stream for audit.

**Window B — acting as Backend:**

gojaja plan # what's waiting for you gojaja task status T-0001 InProgress

`gojaja watch` reference (runtime monitoring)

The Quickstart above already walks through using watch for first-time setup. Once the team is up and running, leave watch open in a browser tab — it is your scheduler view: on a single machine nothing can wake an agent whose turn has ended, so you watch this dashboard to decide who to nudge next.

gojaja watch                 # default: http://127.0.0.1:7421, auto-opens browser
gojaja watch --port 8080     # custom port
gojaja watch --host 0.0.0.0  # share on LAN — read-only mode (Setup + Actions hidden)
gojaja watch --no-open       # don't auto-launch the browser

The dashboard auto-refreshes every couple of seconds and is split into three tabs:

• Dashboard — live state across every window:
• Roles card per role: session live / stale / no-session, pid + host holding it, heartbeat age, and what it's wait-ing for. A role that holds a live session but has not run gojaja wait for a while is flagged red as stalled (the "agent forgot to park after ack" failure mode — the role is deaf to events until it runs wait).
• Task board — every task by status (Backlog → Done), with owner, priority, blockers, and deliverable count.
• RFCs — open / revising / decided, with deciders and voters.
• Activity feed — newest-first event stream across all agents; doubles as the project history.
• Setup (loopback only) — same write surface the Quickstart uses: create roles, install runtime files, generate per-window activation snippets. Useful long after first-run too — adding a new agent role mid-project goes through here.
• Actions (loopback only) — push directly into the team without a terminal: send a report --to <role>, open an RFC, or create a task. All posted as from: SYSTEM (the project-owner channel; the receiver sees it as coming from you, not a peer agent).

What to look at, in order of urgency: - Red stalled chip in the header — a role is unparked. Either send it a directive in Actions or prod the agent window directly. - A role badge idle (waiting for task-assigned) — that role is free; assign it work via the Actions tab. - A task stuck in Blocked — its dependsOn line tells you who to chase; report up the chain. - An RFC sitting at open for too long — the decider needs a nudge.

Both write tabs hide automatically when watch is bound to a non-loopback address (--host 0.0.0.0 etc.) so a LAN-shared dashboard cannot be used to push directives at the team. Ctrl-C in the terminal stops the server.

v3 vs v2

gojaja@3.0.0 ships the central-root split described above. If you initialised a project against an earlier release (anything 2.x), upgrade like this:

```bash

Your job vs the agent's job

This is the most common confusion. Here is the boundary, once.

If you find yourself running gojaja plan or claim by hand, you are probably driving the flow manually for debugging. That's fine — see Driving it by hand below.

---

Setup via the CLI (alternative to the dashboard quickstart)

Four steps. After this, you only chat with the agents.