The chat and its commands

The console is the project’s chat, and it holds the stored transcript, oldest first. It opens only from the logo in the studio. Everything else can prefill the console’s input, but only the logo opens it. While the console is closed, anything waiting for you (a prefilled command, a plan that came back, a failed verification) appears as an “N ready” badge on the logo.

Typed commands are deterministic

No model sits between you and a typed command. The brief reaches the coding agent exactly as you wrote it.

new pipeline <lane>: <what it does>   add a RIVER pipeline lane and file its brief
new app <lane>: <what it is>          add a web app lane and file its brief
change <lane>: <what to change>       file a brief for that lane
project <name>                        name the project (its repo)
status · help

project <name> names the project. The first approval creates the repo org-runink/<name>. Once the repo exists, the name is fixed.
new pipeline|app <lane>: <brief> adds the lane if it does not exist and files its brief. With no brief it only adds the lane to the draft, and FORGE answers: Lane "…" added to the draft (…). Nothing is filed until you send its brief: change <id>: …. A bare new <lane>: … is a web lane. new app or new pipeline with no name is refused with A name is required.
change <lane>: <brief> files a brief on an existing lane. An unknown lane gets This project has no lane "…". Its lanes: ….
status re-reads GitHub and prints one line per lane, for example ingest (RIVER pipeline, pipelines/ingest/): 1 open · 0 done · checks pending.
help (or ?) prints the command list.
A line that starts with new, change or status but does not parse is treated as a typo and gets the help text. It is never sent to the planner.

Your send is the approval. Sending a new …: <brief> or change …: <brief> calls ApproveChat, which is the only write to GitHub. If the project has no name yet, you get Name the project first — it becomes the repo: project <name> and nothing is sent.

Free-form text goes to the planner

Anything that is not a command goes to the planner. Its steps come back as prefills: they fill the input, and you edit and send them yourself. They are never filed on their own.

Linked commands: `/forge/?cmd=`

CORE (or any link) can open the studio with a command already typed in: /forge/?cmd=<command>, where the command is percent-encoded as a query component. A + reads as a space, so write a literal plus as %2B. On load, FORGE:

puts the text in the console input with the cursor at the end. It does not open the console, and the logo shows “1 ready”. It never sends: your send is still the approval;
caps the text at 8000 UTF-8 bytes for the whole command. Past the limit it cuts at the last whole line and shows a red note with both sizes;
ignores a missing, blank or undecodable cmd, and drops control characters other than tab and newline;
removes cmd from the address bar, so a reload does not prefill it again.

No CORE page builds a ?cmd= link today. The contract is kept.

View parameters: `?chat=` and `?panel=`

These parameters only choose what to show. They never prefill and never file.

Parameter	Effect
`?chat=<id>`	Opens that chat: `c-<16 hex>`, or `repo-<name>` for an imported app. Any other value is ignored.
`?chat=new`	Opens a new, empty chat. It is stored only once something is added to it.
`?app=<name>`	Legacy. Opens `repo-<name>`.
`?panel=components\|draft\|details`	Opens the side panel on that view. There is no `console` value.

FORGE keeps chat in its address in step with what it shows, so a reload shows the same chat. CORE’s deep link /?tab=forgeStudio&chat=<id> opens a chat from the console.

Sources

flutter/lib/features/forge/intent.dart; flutter/lib/features/forge/project/project_loop.dart (submit, projectGreeting); flutter/lib/features/forge/link_prefill.dart; CLAUDE.md (“Linked commands”).

Projects and lanes The planner