@markmo/europacore-cli
v0.4.11
Published
Terminal UI for europacore agents, speaking the europacore server API (europacore/docs/server-api.md)
Maintainers
Readme
europacore-cli (ec)
A terminal UI for europacore agents. It talks to the europacore server API (HTTP + Server-Sent Events). The protocol is specified in europacore/docs/server-api.md, so the same server also works for web UIs, bots and scripts.
It is built on @earendil-works/pi-tui, the differential renderer behind pi:
- Flicker-free synchronized output, and native scrollback by default.
- A full-screen mode with app-owned scrolling, search and mouse support.
- A multi-line editor with history, kill ring, paste handling and slash/path autocomplete.
███████╗██╗ ██╗██████╗ ██████╗ ██████╗ █████╗ ██████╗ ██████╗ ██████╗ ███████╗
██╔════╝██║ ██║██╔══██╗██╔═══██╗██╔══██╗██╔══██╗██╔════╝██╔═══██╗██╔══██╗██╔════╝
█████╗ ██║ ██║██████╔╝██║ ██║██████╔╝███████║██║ ██║ ██║██████╔╝█████╗
██╔══╝ ██║ ██║██╔══██╗██║ ██║██╔═══╝ ██╔══██║██║ ██║ ██║██╔══██╗██╔══╝
███████╗╚██████╔╝██║ ██║╚██████╔╝██║ ██║ ██║╚██████╗╚██████╔╝██║ ██║███████╗
╚══════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝
agent workspace · powered by the europacore harness · v0.1.0
────────────────────────────────────────────────────────────
▸ Agent coder — Reads, edits and tests code in your repository
▸ Tools bash, read_file, edit_file, todo_write
▸ Model claude-sonnet-4-5
▸ Server mock
› why is the test flaky?
✻ Thought for 1.4s · ctrl+o to expand
Let me run the test suite to see what's failing.
✓ bash pytest -x tests/ 270ms
── ⠧ thinking · step 2 · 4.4s ──────────────────────────────────────────────────
────────────────────────────────────────────────────────────────────────────────
coder · claude-sonnet-4-5 · “why is the test flaky?” ▂▆▄▄▄▂▂▂ 21% · 4.2k tok · $0.017
escape cancel · enter steer · alt+enter queue · ctrl+o details ● live · mockThe startup banner is the same as europacoreui's (backend/app/banner.py): block lettering shaded with the brand teal. Narrow terminals get compact lettering, and NO_COLOR gets plain text.
New to ec? Start with the guide, a chapter at a time with screenshots, or the user guide on one page. Running the server yourself is covered in europacore's docs/server-settings.md.
Install
npm install -g @markmo/europacore-cli
ec --mock # try it with the built-in mock serverQuick start
From a checkout:
npm install
npm start -- --mock # try it with the built-in mock server, no Python needed
npm start -- --server http://127.0.0.1:8765 --token "$TOKEN"
npm start -- --spawn myapp.agents:registry # runs `europacore serve` for you
npm start -- --code # the coding agent, working on the checkout you are inCoding on your checkout
ec --code in a git repository starts europacore serve europacore.coding:agents --workspace-root <repo> and creates sessions in the current directory. The agent reads, edits and tests your code there, with its commands confined by the OS sandbox (see europacore's europacore.coding). Pass -w DIR to work in another directory, or combine --code/-w with --server or --spawn to use a server you run yourself (it needs a matching --workspace-root).
File edits show as coloured diffs in the tool row (the first lines;
ctrl+oshows all), and commands show their exit status, with the end of their output when they fail.Claude Code. With europacore's
claude-codeextra (pip install 'europacore[claude-code]') and a logged-inclaude, the coding server also serves theclaude-codeagent: Claude Code running its own agent loop in the same checkout.ec --code -a claude-codestarts one, and/agent claude-codestarts one beside the sessions you have. Streaming, diffs, approvals (akeeps Claude Code's rule for that exact call for the session), questions, images, background tasks, steering,/fork, the overview, the memory and reattaching work as forcoder. Claude Code's own settings,CLAUDE.md, hooks and MCP servers apply, but europacore's OS sandbox does not. Two server-side variables matter most:EUROPACORE_CLAUDE_PERMISSION_MODEsets which tools ask (defaultacceptEdits: edits go through, commands ask), andEUROPACORE_CLAUDE_MODELpicks the model (sonnet,opus,haiku). The rest are in europacore'sdocs/claude-code.md.The footer shows the branch and the changed files (
⎇ main 2 changed +14 −3), refreshed after every tool that may write.Routed models. On the model
router(--model router, or/model router), a line says which tier and model each turn runs on and why (· Model routed to fast (claude-haiku-4-5): confident fast at 0.97), and the footer shows them (claude-haiku-4-5 fast). A switch to a cheaper model that its cold prompt cache would make dearer is held, with both costs. Needs a europacore server with the model router on (EUROPACORE_MODEL_ROUTER)./changeslists the changed files;/diff [path]shows the diff againstHEAD.Pull requests. A pull request
coderopens is followed: the footer shows its CI (PR #12 ci ✗ unit-tests,ready ✔). With the server's webhook triggers, a repeated CI failure, a trusted reviewer's comment or a conflict with the base comes back to the session as a⏵ PR #12: …run once it is idle; pushing the fix still asks./prlists them,/pr follow <url>adds one opened elsewhere,/pr unfollowstops it,/pr openopens it.Git panel.
ctrl+g(or/git) pins git for the session above the editor, and keeps it up to date while shown:Git · ctrl+g hides · /changes lists files · /diff shows them Repo europacorecli github.com/markmo/europacorecli Branch ⎇ main → origin/main · ↑1 Path ~/src/europacorecli Changes 2 files +180 −12 M src/ui/session-view.ts +48 −2 ? src/ui/git-info.ts +120 −0 Session 18 files +161 −65 since 8019d9a Commits 1b78254 ec: keys that match Claude Code's · 8 minutes ago … 2 more Tasks 2 worktrees · 1 merged · /tasksThe branch, path and uncommitted changes come from the server. The remote, upstream,
Session(what changed since the session started, committed or not) andCommits(made since it started) come fromgiton this machine, so they show only when its checkout is at the workspace's commit, as withec --code. Task worktrees and added directories show when there are any.@pathcompletes file paths in the workspace; the agent reads the files you mention.Sessions are kept in
~/.europacore/state/<repo>-<hash>.db, one file per repository, soec --code -creopens the last session afterec(and the server it started) exits.Running commands show their latest output under the tool row. While delegated tasks run, a Tasks panel above the editor lists each one with its worktree and what it is doing (its current tool call), and each delegate row shows the same.
Background tasks. A command the agent leaves running (a dev server, a long test run) and a sub-agent it delegates in the background appear as "background command" and "background sub-agent" rows, and in the Tasks panel with their running time and last line of output until they finish. When one finishes while the session is idle, the server wakes the agent: a
⏵ Background task finished: …line starts a run of its own, which can ask for approvals like any other./taskslists them, and/tasks stop [id]stops one (with several running, it asks which).Monitors. A command the agent leaves running so its output wakes it (
monitor: a log's errors, CI steps) or a watch on files (watch_files) is a "monitor" row, its last lines as its tail;/taskscounts its events. What the agent is given of its output shows where it read it:◉ monitor “errors in app.log”with the lines quoted below, and how it ended. When it has news while the session is idle, a⏵ Monitor news: …run starts;/tasks stopstops it.A new worktree's setup (
setupin.europacore/worktree.toml) shows as a live "setup worktree" row; the first turn starts once it finishes.
Moving a session to the cloud. /cloud hands the session to the cloud server europacore cloud login <url> saved (a devassistant, say), which carries on with the checkout in a sandbox: close the laptop and it keeps going. The footer shows ☁ cloud while this session mirrors it; reopen ec and it catches up. ec --cloud connects straight to that server instead, to follow the sessions there without the laptop's own (europacore docs/cloud.md). /cloud return brings the session back: its branch, its uncommitted work and its whole history, into the checkout it left (refused while that checkout has changed since). /cloud sessions lists the cloud's coding sessions, so one that started there can be brought into the checkout ec runs in, as a new session.
Worktrees and parallel tasks. ec --worktree (with --code, or -w DIR) gives each new session a git worktree of its own, on a branch europa/session-…, so your checkout is untouched while the agent works. When the work is good, /accept [commit message] fast-forwards the branch you started from (committing leftovers with the message); /discard [force] removes the worktree and branch. /cleanup (or /prune) gathers up what is left over in the repository: every worktree, local branch and branch on GitHub whose work is merged, listed with what would go, what stays and why, and the session (here or in Claude Code) that made it, all ticked; enter removes the ticked ones. The server snapshots the workspace's files at the start of each turn, so /undo takes back the last turn (or /undo 3, /undo all), the conversation and the files together, and /redo puts it back; /restore puts back only the files.
One session across repositories. When a change spans more than one repository, add the others as worktrees: ec --code --add-repo ../api (repeatable) starts each new session with a new worktree of that repository on the session's own branch there, and /add-dir ../api worktree (or worktree from <ref> to start from another branch) adds one to a session already going. The agent edits it by absolute path from its next turn, is given that repository's instructions and told its checks, and can open a pull request in each repository it changed. /add-dir lists it as a worktree of the repository it came from; /changes and the git panel (ctrl+g) show each added worktree's changes under its repository's name, and /diff <its directory> [path] its diff. /accept <its directory> [commit message] fast-forwards the branch it started from in that repository, and /discard <its directory> [force] removes the worktree and its branch; /remove-dir only takes it off the session's list, leaving the worktree and branch where they are. /undo and /redo put its files back with the workspace's, and say how many were there (2 files restored (1 in api)). /cloud carries only the workspace, so it names the directories the session may write and asks you to accept, discard or remove them first. This needs a server that says added_worktrees (europacore #419, #420); on an older one ec says the server is too old and adds nothing in its place.
The coding agent also splits larger work into parallel tasks: it delegates parts to coder sub-agents, each in its own worktree and branch, then merges their branches into its own, resolving conflicts and re-running the tests. /tasks lists them, and /review [task] shows one task's changes.
Models. The coding server reads two environment variables when it starts:
EUROPACORE_MODELsets the default model. If it is not set, the default isclaude-sonnet-4.EUROPACORE_MODELSis a comma-separated list of other models sessions may switch to.
The model picker (alt+m, /model) offers only these, and the server refuses any other. ec --code passes its environment to the server it starts. If you run the server yourself, set the variables there:
export EUROPACORE_MODEL=claude-opus-4-7
export EUROPACORE_MODELS="claude-haiku-4-5,gpt-6.1-sol"
ec --code # or:
europacore serve europacore.coding:agents --port 8765 # then `ec --code --server ...`europacore's create_model picks the provider from the name:
| Name | Provider |
|---|---|
| claude-* | Bedrock. Short names must be ones BedrockConfig.CLAUDE_MODELS knows, such as claude-opus-4-7 or claude-haiku-4-5. |
| anthropic.*, global.anthropic.* | A Bedrock model ID. |
| gpt-* | OpenAI (Responses API). This needs europacore[openai-responses] and an OpenAI API key. |
| openai.*, global.openai.* | GPT through Bedrock's OpenAI endpoint. |
To choose the provider explicitly, add a bedrock/, openai/ or bedrock_openai/ prefix. -m ID picks one of the allowed models for new sessions.
There are four ways to connect, checked in this order:
--mockruns the built-in mock server.--cloud [TARGET]connects to the cloud servereuropacore cloud loginsaved (defaultunless named), with its token.--spawn MOD:ATTRstartseuropacore serve MOD:ATTR --port 0and reads its ready line. SetEUROPACORE_SERVE_CMDto change the command, e.g.poetry run europacore.--server/EUROPACORE_URLconnects to a running server. The default ishttp://127.0.0.1:8765.
The token comes from --token, EUROPACORE_TOKEN, --token-file, the sign-in ec login saved for the server, or ~/.europacore/server-<port>.token, which europacore serve writes.
Signing in
A server started with europacore serve --auth identity signs people in instead of taking one shared token (europacore's docs/sign-in.md). Each person works as themselves, in the workspaces they belong to, the same as on its web page.
ec login --server https://agents.example.com # email and password, asked for
ec login --server https://agents.example.com --provider google # in the browser: Google or GitHub
ec --server https://agents.example.com # signed in from now on
ec workspaces --server https://agents.example.com [ID] # list them, or work in ID
ec logout --server https://agents.example.com- What is kept.
ec loginkeeps the token the server gives it in~/.europacore/ec-logins.json, readable only by you, per server. It lasts 14 days unused and 90 at most, after whichecsays to sign in again. - A provider. With a provider,
ecopens the server's sign-in page in your browser and listens on a loopback port for it to come back. It trades the one-time code it receives for its token, with a PKCE verifier that never leavesec.EC_BROWSER=noneprints the link instead of opening it. - Scripts.
--emailand--password-stdinsign in without prompts. A script can also use a personal token from the web page with--token.
The server's settings
Many of europacore's EUROPACORE_* settings can be changed while the server runs (europacore's docs/admin-settings.md): the server's by a superadmin, or by a token server's operator, and a workspace's by its admins. /settings picks one and changes it: the scope when you may change both, then the group, then the setting, which shows the value its sessions read and where it comes from (0.65 (default), on (server)), then its value. A flag or a setting with fixed values is a list (with the default and, when one is saved there, reset); anything else is typed, ctrl+r resetting a saved one. A superadmin's change to the server's settings asks why. The notice says what it was and when the change applies: at once, or for sessions started after it. A value the server refuses is asked for again with its reason, and a superadmin whose sign-in is too old is told to run ec login again. /settings changes [server|workspace] lists what was changed, by whom and why. esc goes back a step. A member sees nothing to change, and a server that keeps no saved settings says so.
ec settings --server https://agents.example.com # the settings you may change
ec settings set compaction_threshold 0.6 --reason "longer runs" # EUROPACORE_ may be left off
ec settings set thinking high --scope workspace # yours, not every workspace's
ec settings unset compaction_threshold --reason "back to the environment's"
ec settings changes --scope serverec settings connects as ec does (--server, --token, --token-file, else your ec login). --scope is needed only when you may change both and the setting can be set per workspace. "" saves the documented default, whatever the environment says; unset removes the saved value, so the environment's applies again.
npm start -- runs from source. To get an ec command instead, run npm run build && npm link.
Several sessions at once
One ec window can follow several sessions. One is shown; the others keep streaming in the background, so a long run, a decision waiting for you and a quick question can all go on at the same time.
Open more sessions.
/newstarts another one and/sessions <id>(or/resume) attaches an existing one; the session you were in stays attached.alt+.andalt+,cycle through the attached sessions. Each keeps its own transcript, editor draft, queued follow-ups and pending decision.Zoom out.
alt+s(or/sessions) replaces the screen with an overview of every session on the server, attached or not.alt+soresczooms back in.Sessions · sorted by needs input first · zone 20–60% · 2 attached · ⏸ 1 needs input ───────────────────────────────────────────────────────────────────────────────────────── › ⏸ delete the build dir coder ▆▂▄▄▄▄▄▂▂▂▂▂ 8% 3.8k tok $0.015 just now ● a long build coder ▂▆▄▄▄▄▄▂▂▂▂▂ 11% 5.4k tok $0.022 just now ○ why is the test flaky? coder ▂▂▆▄▄▄▄▂▂▂▂▂ 21% 10k tok $0.041 4m ago ───────────────────────────────────────────────────────────────────────────────────────── Session coder · claude-sonnet-4-5 · waiting for you Prompt delete the build dir Answer I need to delete the stale build directory before rebuilding. Memory nothing yet ↑↓ move · enter open · → answer · n new · / filter · e rename · * pin · tab · b board · s sort …- Row marks.
⏸waits for your input,●is running,○is idle and✗failed last time. A!after the mark means something happened while you were looking elsewhere. Titles of sessions that are only listed, not attached, are dimmed. - Detail pane. Under the list is the highlighted session's brief (see below), or, for a session that is not attached, its agent, model and usage.
- Keys.
enteropens the highlighted session, attaching it if need be.schanges the order,ddetaches andrrefreshes the list (it also follows the server's session feed as sessions change, or refreshes every 2 seconds on a server without it).tabswitches to the inbox and back;spaceopens a fleet's tasks under its row;bshows the board. - Peek.
→(orl) acts on the highlighted session without opening it. When it waits on a decision, its own card takes the place of its brief: an approval, a question or a plan, answered with the keys it has in the session. Otherwise a reply line opens:entersends the message as the session's editor would (steering a running turn, starting the next one, answering a question in words) and leaves you on the overview; an empty one opens the session.escgoes back to the list, keeping the decision and anything typed. A session that is only listed is attached out of view first. - Starting sessions.
nopens a line for a new session's prompt:enterstarts it here, out of view, and puts the cursor on its row, so several can be started in a row andenteropens one. An empty line opens a new session, asndid before. - Filter, pin, rename.
/filters the rows as you type, on titles, agents, models, workspaces and branches;a:NAMEmatches the agent,s:STATEthe status or stage (s:waiting,s:review) andp:PROJECTthe project (p:none: in none).enterkeeps the filter (shown in the header), andescclears it.*pins a session to the top, in every order. A server that keeps pins (capabilities.session_pins) keeps them with the session, so every client of it shows the same ones; an older server leaves them to the window, per server and repository.erenames the highlighted session. - Stages. Each row says where its work is and for how long: Backlog, Planned, Blocked (it waits for you or failed), In progress, In review (finished with changes not accepted yet), Done or Cancelled. A session's stage follows from what it does;
/stage backlog|cancelled|clearsets one while it is idle. The progress column shows a plan's steps (plan 2/4) or a fleet's tasks (3/5 passed).
- Row marks.
Board.
alt+k(or/board, orbin the overview) shows the same sessions as a kanban board: a column per stage, from Backlog through Planned, In progress, Blocked and In review to Done. Every session, fleet task and fleet run no session follows has a card. A fleet's tasks are cards of their own, under its name.alt+korescgoes back to where you opened it.● In progress 1 ⏸ Blocked 1 !1 ✓ In review 1 ────────────────────────── ────────────────────────── ────────────────────────── ╭────────────────────────╮ ╭─ ! waits for you ──────╮ ╭────────────────────────╮ │ ● a long build │ │ ⏸! Pick a cache │ │ ○ Move the session h… │ │ coder · ⎇ main │ │ ↳ fleet: auth │ │ ↳ fleet: auth │ │ ⏱ 4m02s 24k tok $0.31 │ │ ⏱ 1m10s 9k tok $0.03 │ │ ⏱ 2m31s 13k tok $0.06 │ ╰────────────────────────╯ ╰────────────────────────╯ ╰────────────────────────╯Cards. Each card has:
- the status mark and title
- the agent, or the fleet the task belongs to
- how long it has run (or how long it has been in its stage), its tokens and its cost
What it needs from you (waits for you, failed, collision, ready to merge, finished, rule offered) is in its top border. Long titles are cut so every column is the same width; a terminal too narrow for all the columns shows those around the highlighted card, with
‹/›counts of the rest.Detail pane. It is under the board, as in the overview.
Keys.
←→move between columns,↑↓within one, andenteropens the card. A fleet task's keys work as they do in the overview (o x R t p i m).cshows the Cancelled column.
Inbox.
alt+i(or/inbox) opens the overview on what needs you, oldest first: decisions waiting, then failures, then sessions and fleet tasks that finished while you were away, and last sessions with a mistake offered as a rule (Rule offered,3 rules offered).enteropens the session with that decision in front of you; a finished row leaves the inbox once opened, or withm.Order.
sin the overview, or/sort <mode>, orders the rows. The choice is saved in~/.europacore/config.json.| Mode | Order | |---|---| |
recent| Most recently active first | |context| Largest share of the context window first | |closest| Closest to the optimum zone first (inside it counts as 0) | |furthest| Furthest from the optimum zone first | |input| Waiting for input, then running, then failed, then idle | |stage| Grouped by stage: blocked, in progress, in review, planned, backlog, done, cancelled |Sessions whose context is not known yet go last in the context orders. Ties go to the most recent.
Context gauge. Each row, and the footer, shows how much of the model's context window the last call used, against an optimum zone: the middle-height
▄cells are the zone, the low▂cells the rest, and the tall▆marks the current use. None fills its line, so the bars of neighbouring rows stay apart. The colour is muted below the zone, green inside it, yellow above it and red from 90%. The zone is 20–60% unless"optimum": "30-70"in~/.europacore/config.jsonsays otherwise;--optimum 30-70changes it for one run.Out of view. When a background session starts waiting for you, finishes or fails, the footer says so, and a line above the editor counts the others:
other sessions: ⏸ 1 needs input · ● 1 running — alt+. next · alt+s overview. The window title gets a⏸2suffix while two others wait.Progress. A panel shows where the session has got to, like the sidebar in Claude's apps: the plan's steps (the done ones before the last two counted as earlier steps, the current one in bold), what the agent made (its pages, pull requests and the files it wrote), and what it used (web searches, the sites it fetched, MCP connectors, skills and the images you sent). With
--fullscreenin a terminal 110 columns or wider it is a column on the right, beside the transcript and the editor; otherwise it sits above the editor, in the plan panel's place:Progress · alt+g hides Steps 3/5 2 earlier steps ✔ Check the tracker for reports from users ◐ Write up notes ○ Publish the findings as a page Outputs ✎ notes/checkout-latency.md +27 −1 Used ⌕ 2 searches · ↗ example.com +1 · ⧉ github ×2 · ✦ report-writerIn the column, each section has its own heading, and every search, site and connector its own row.
It shows once there is something in it.
alt+g(or/progress) hides it in every session, and the choice is saved in~/.europacore/config.json("progressPanel": "off").Brief.
alt+r(or/brief) pins a brief above the editor: the session's first prompt, its plan with each step's status, the start of its latest answer, and how many decisions and requirements are remembered from it./recapasks the agent for a two- or three-line recap (the goal, what is decided, what remains), and the brief then shows that recap.Collisions. On a europacore that keeps file claims (
capabilities.peers), the server settles who writes a file between the agents:- A session that writes a file owns it until the change is committed. Another session's write to it is refused (
Not written: P is claimed by “A”: asked them for it), and the owner's agent is asked for it. - The owner answers per file: give it, keep it, share it with a boundary, let the asker have it when it is done, or make the asker's change itself. The asker may counter once, and the owner's reply is final.
- Each request, answer and ending is a notice in both sessions and a flash in the footer. Messages between the agents show as
✉ from “A”: …. - Sessions of your workspace see each other's claims, a teammate's named with its user:
“Tidy the cart module” (sam). - A request the agents could not settle is in the inbox until your next message to the session.
A session handed off to the cloud keeps its claims there, and is marked
☁./claimslists who holds what, with boundaries, queues and the open requests with their round./claims release <path>lets go of one of the session's files,/claims give <path> [session]hands a file of one of your sessions to another, and/claims ask <path> [reason]asks for one, a teammate's too.Against an older server,
ecwatches for collisions itself. Two attached sessions changing the same file of one repository (in one checkout, or in two worktrees while both write it) are a hard collision. Each side that edits without asking is switched to asking until it is over, then put back; the footer says so, and the inbox lists them. An edit approval on such a file names the other session and offersh(hold until they are done) andt(leave the file to them). The same directory is a softer warning.- A session that writes a file owns it until the change is committed. Another session's write to it is refused (
Learned rules. Each mistake you catch in a session (a rejected call, an
/undo, a steer, or/mistake <what went wrong>, which marks the last turn) comes back as a rule the agent could check next time (europacore'sdocs/rules.md). When the server has drafted one, the session saysRule offered: You marked a mistake — /rules to decide, and the overview, the board and the inbox showRule offered./ruleslists the repository's offers, numbered, each with its draft (denyorask, the patterns and why), what it would have caught and what it would stop, then the rules in force with how often each fired and was approved past lately, andRetire?where one has earned it:/rules keep <n> [project|user]adds the draft to.europacore/rules.toml(commit it with your changes), or to your own rules file;/rules edit <n>opens it in$VISUAL/$EDITOR(do,scope,matchone pattern per line,because) and keeps it as saved; a prose draft becomes a rule only this way;/rules waive <n> <why>says it is not a rule;/rules test <n>, for a code mistake whose change was kept (an/undowith files, or a/mistake; its offer saysChanged: <files>), asks, then has the server's fleet write a regression test that fails on the change you took back and passes now, from the day's improvement budget. The offer then saysWriting a test…with no actions; ec doesn't poll, and the next/rulesreads how it went: a test that passed is listed underTests writtenasw1,w2… with its branch, and one that didn't is open again withThe last test didn't pass: <why>./rules land <wN>asks, then accepts the run, putting the test on the base branch. A server with no fleet says it can't write tests, and/rulesstops offering them;/rules retire <id> [project|user]asks, then takes a rule out of its file;/rules tidy <tN>applies one of the ways to tidy the rules files that/ruleslists underTidyast1,t2… (Merge,Covered,Never asks,Group, each with why): it asks, rewrites the file, and lists the rules as they now stand;/rules draftdrafts the mistakes that have no offer yet, within the day's improvement budget.
A server with improvement turned off keeps no learned rules, and
/rulessays so.Letting go.
/detach [id](ordin the overview) stops following a session in this window; its runs keep going on the server, and it stays in the overview's list. Up to 16 sessions stay attached; opening another lets go of the least recently viewed idle one.Quitting prints an
ec --session <id>line for every session still running or waiting for a decision.The next start attaches the same sessions again, out of view, and says how many;
ecstill opens on a new session, andec -copens on the session you were last looking at. Sessions the server no longer has are dropped with a note. The list is kept per server and repository in~/.europacore/windows/, updated as you attach, detach and switch.--freshstarts without them. Nothing is kept for--mock, whose sessions end when it does.
alt+., alt+,, alt+s, alt+i, alt+k, alt+l, alt+a, alt+w, alt+m, alt+r, alt+g, alt+1 to alt+3, the alt+shift arrows and alt+enter need the terminal to send Option/Alt as Meta (in iTerm2: Profiles → Keys → Left Option key → Esc+; in Terminal.app: Use Option as Meta key). Rebind them in ~/.europacore/keybindings.json if you prefer, e.g. {"app.nextSession": "alt+j"}.
Fleets
A fleet runs many coding tasks over one repository, each in a worktree and session of its own, scored by its checks and merged as it passes (europacore's docs/fleet.md). In ec a fleet is a session of the fleet agent, which the server offers when it runs with --fleet, so it streams, waits, reattaches and shows in the overview like any other session.
Fleet · auth · 1/3 passed · 1 running · ⏸ 2 waiting · alt+w next · alt+i inbox
› ⏸!Remove the old module waits: approval 12s
⏸!Pick a cache waits: question 8s
✔ Move the session helpers Done scorers 1/1 40s/fleet tasks.tomlstarts a fleet session and sends it the spec (/fleetwith the TOML or JSON itself works too). A spec that can't run comes back with what is wrong with it.- The panel above lists the run's tasks with their stage, progress and time in it, and each run event is a row in the transcript.
- Several tasks can wait at once.
›points at the decision shown,alt+wshows the next, and the inbox lists them all. Each is answered like any other decision. /cancel TASK(orall),/retry TASK [note]and/steer TASK TEXTcommand the run; other text goes to every running task./review TASKsays where a task is and why.- In the overview,
enteron a task opens its worker's session, read-only and live: its decisions are answered there through the fleet, typing steers the task and/cancelcancels it.oopens the fleet with the task's decision instead. - The fleet holds the later of two tasks that change the same file until the other has merged (
held for <task>);/release <task>lets it go on.collisions = "warn"in a spec asks instead. - A run that publishes a pull request stays open in review: its checks show in the panel (
ci ✗ unit-tests,ready ✔ to merge). The server's webhook triggers rerun a failing check once, route a repeated failure or a review comment to the task that owns the files as a follow-up, merge in a conflicting base, and say when it is green and approved./fleet propens the pull request. - Runs started without a session (by a trigger, the command line, an agent or a flow) are listed with where they came from;
enteradopts one into a fleet session. /fleetwith plain words drafts a spec for you to approve, edit or send back; nothing runs before you approve it.- A run or task with
plan_gate = "required"proposes a plan before it builds, approved like a session's (see Plans). - Once a merge has conflicted,
⇄ integrationshows the fleet's integrator;enteron it, orion the task, opens its session read-only. - Fleets you haven't opened list their tasks in the overview and the inbox too.
/bestof 3 --models a,b,c -- <task>(orvariants/best_ofin a spec) runs a task several ways. When they finish, a comparison shows each variant's checks, change, cost and time side by side, every file against each of them, and a file's diff.ppicks the one to merge,/pick <variant>does it directly, andpon a variant's row in the overview compares at any time.ttries a variant: a shell in its worktree, to run the app on its changes, while your checkout stays as it is (exitcomes back;ccopies acdthere instead).ton any fleet task's row, and/shellin any session, do the same./acceptfast-forwards the base branch to a completed run's merged work, and/undotakes the run back (its work is kept underrefs/europa/).
Plans
In plan mode the agent only reads, then proposes a spec (goal, scope and non-goals, approach, acceptance criteria, open questions) before it changes anything. /new --plan starts a session in it, /mode plan switches one, and the footer says plan mode. The plan replaces the editor as a card: y approves it, a approves it and builds with edits accepted, e edits it in $VISUAL/$EDITOR (then y approves your version, u undoes the edits), n sends it back with feedback, and ctrl+o shows all of it. Approved, it is written to .europa/spec.md (never committed), the agent builds against it, and the overview lists its acceptance criteria.
The decision register
ec keeps a register of the key decisions and requirements of your sessions. It is a file per repository, ~/.europacore/memory/<repo>-<hash>.jsonl (a file per server for sessions without a workspace), shared by the repository's worktrees. Every entry is also copied into its session's metadata.ec_memory on the server, so another client opening the session picks the entries up.
Entries arrive four ways:
- You record them.
/decision <text> [-- why]and/requirement <text> [-- why](/dec,/req). The reason goes after--. - Approval prompts. Every approval, rejection, delivered event or abandoned wait becomes a decision, with the tool and its arguments, and your reason when you give one. The transcript row shows its id:
✓ Approved for this session: run `npm test` [D-003]. - The agent marks them. Lines in an answer that start with
Decision:orRequirement:(bullets and bold allowed), and the bullets under a## Decisionsor## Requirementsheading, are remembered as the answer finishes. A sub-bullet startingrationale:orwhy:gives the reason. - You ask the agent.
/decisions extractasks it to list the decisions and requirements agreed so far. A checklist of the new ones replaces the editor:spaceunticks one,aticks all or none,enterkeeps the ticked ones andescdrops them.
Each entry gets an id, D-001 for decisions and R-001 for requirements, numbered per repository. An entry already remembered for the session (ignoring case, emphasis and trailing punctuation) is not added twice.
| Command | |
|---|---|
| /decisions | This session's entries |
| /decisions all | Every entry of the repository |
| /decisions retire <id> | Mark an entry as no longer in force |
| /decisions edit <id> <text> [-- why] | Reword an entry |
| /decisions supersede <id> <text> [-- why] | Replace an entry with a new one that records what it replaces |
| /register [file] | Write the decision register: .md (the default, decision-register.md), .csv or .json |
The Markdown register has a table each for decisions and requirements in force, with the id, date, statement, reason, source and session, then the superseded and retired entries.
Long-term memories
The agent's long-term memories are the server's, not ec's: what europacore agents keep about an org, a user and a user's project across sessions (europacore docs/memory.md). The decision register above is ec's own record of a session's decisions; long-term memories are what the agent itself reads at the start of every session. /memory (or /memories, alt+l) browses them full screen:
Scopes. The scopes pane lists all memories, the org's, yours, and each of your projects, the session's first, with counts. Below them are smart views: pinned memories (on a server that pins them), pages (once there is one), then by flag: stale, duplicates, never recalled, over the index cap, forgotten.
The table. A row per memory: its name, source (
agent,extractor,dreamer,cli…), body tokens, recalls and flags.◆marks a pinned memory and≡a page; a scope's pages come before its notes.The preview. Who wrote the memory and when, how often it was recalled, its tokens (its index line on every call, its body when read), when it loads, its body, and a callout per flag (
duplicate of deploy-schedule: same topic (deploy)).Pinned memories. A pinned memory's body is in every session of its scope, not only its index line (europacore
docs/memory.md, "Pinned memories"). Its view says who pinned it (the person, when the server names one, ora dream,the CLI…), when and why, and its scope's pins against the 4,000 characters every session carries (user dev: 1 pinned · 105 of 4,000 chars); so does the header of a scope, and of the Pinned view for every scope. A memory a dream unpinned says so.ppins the selected memory, or unpins it, after asking why (optional;enterwith nothing sends no reason,escsends nothing). When the server refuses (the scope's pins would go over 4,000 characters, or you may not write that scope), its words are shown whole: they name the pins to unpin. Pages are never pinned. Needscapabilities.memory_pins. These are not a session's pin (*in the overview), which keeps a session at the top of your lists.Pages. A page is a subject's map over its scope's notes, written by a dream or a person; a server's pages are off until
EUROPACORE_MEMORY_PAGES=1. Its view draws each[[name]]link in its body, and lists what it links underLinks; a link to a name with no active memory in the scope is marked broken (✗) and leads nowhere. A note's view lists the pages that link it underLinked from, and says when a page's index line stands for its own. In a memory's view,tabandshift+tabpick a linked memory,enteropens it, andescgoes back to the memory it was opened from; the header shows the way you came (billing-deploys › deploy-day). A page is edited astype: page, with a body of up to 12,000 characters; abloatedpage is longer than the notes it links.Changes.
eedits the memory in$VISUALor$EDITORas markdown (name,description,type, then the body). The edit is saved against the revision you opened, so it doesn't overwrite a write the agent made meanwhile. A refused edit is kept, and the nextereopens it.fforgets a memory,rrestores it, andhshows its history.
The context view.
c, or/memory context, shows what the session loads, in order:- each source with its share of the context and window: the system prompt, the tools, each instruction file (
CLAUDE.md,AGENTS.md, rules), the environment, each memory scope's index and pinned memories, and the conversation; - diagnostics: what memory costs every call (the index, and the pinned bodies), and the duplicates;
- with
m, the merged text, each line tagged with the number of the source it came from.
Before a session's first turn, a memory index is a preview (
◌).- each source with its share of the context and window: the system prompt, the tools, each instruction file (
Needs a europacore server with long-term memory (europacore serve --memory); the context view needs capabilities.context_sources.
Artifacts
Artifacts are the pages agents make with artifact_write: a report, a dashboard, a prototype, kept on the server with every version at one link (europacore docs/artifacts.md). /artifacts (or /artifact, alt+a) browses yours full screen:
- The list. A row per artifact: its format (
HTML,MD), title, the session that made it, its age, and↗while it is published (amber when it expires within 15 minutes,↻when it needs publishing again).tabsteps through the filters: all, this session (what the shown session made, changed or published), published, and stale (published at an older version, or a temporary page past its expiry)./searches titles, ids, descriptions and session titles. - The detail. Beside the list from 120 columns, under it below that: the viewer link (its token hidden), created and updated, files, size and ≈tokens, where it is published and until when, the session that made it, and its versions, each naming the session that wrote it when that was another.
- Keys.
⏎puts@artifact:<id>in the prompt for the agent to read withartifact_read;oopens andycopies the link (the published page while it is up, else the viewer page);Ycopies a temporary page's claim link;vlists the versions to open or copy one;ropens the session that made it. - Kept current. What the sessions attached to this window write, publish or delete shows while the screen is open;
Rreads the list again for the rest. - By repository.
ggroups the artifacts under the repository each was made in ("Not in a repository" for the rest), then under what made them: a session, by its title and agent ("A deleted session" once the server no longer has it), a fleet run, or, for what others share with you, "Shared by "; "No session recorded" goes last. An artifact stays where its first version was written. The groups with the newest artifact come first. On a heading,d,X,AandUtake its artifacts, andropens a session's; a repository'sdasks for their count typed. - The ledger.
t, or/artifacts --table: sortable columns (sthe next,Sreverses),spaceticks a row andaticks them all, and a Σ row of totals. - Usage.
u, or/artifacts --stats: cards for the count, ≈tokens and their cost, storage over every version, what is published and what nobody has written to for 30 days; the ≈tokens per week as bars; the formats; and the heaviest.←→pick a week and⏎lists what was written in it;wwidens the window (4, 8, 12 or 26 weeks);pcounts only the shown session's repository;copens the ledger on the untouched ones, oldest first, andson the stale ones;Xexports what it counts. - Exporting.
X, in any view, offers what suits what is selected: a CSV of the rows (without their viewer links), a ZIP of a version's files, a PDF of the page as it prints, and the source as written: Markdown for a Markdown artifact, HTML for an HTML one. In the versions view it exports the version picked. Files go to.europa/exports/in the workspace. PDFs are printed by a local Chrome, Chromium or Edge, headless, in a profile of its own;EC_CHROMEnames another. - Who can open it. On a europacore that keeps access, an artifact is private to you unless you share it.
A(several at once from the ticked rows in the ledger) makes it private, shares it with everyone signed in to your workspace, or makes it public to anyone with the link; it can also revoke every link given out. Narrowing who can open it stops the links others already have, and ending a public link is for good: making it public again gives a new one. Making it public, ending a public link and revoking ask first.◑marks one shared with your workspace and●a public one; the Shared tab lists yours that others can open, and Shared with me what others in your workspace share with you, which you can open, copy a link to and export, but not change. A private or workspace link opens for whoever has it until it expires (a day by default):oandyget a fresh one when it is close. The detail pane and the ledger show how often each page was opened in the last 30 days, by whom (the link, people signed in, you), and the delete dialog says so too, withpto make it private instead. - Taking a published copy down.
Utakes down the copyartifact_publishput on your Cloudflare account (permanent), after asking; its address stops opening and the artifact stays. A temporary page belongs to no account until someone claims it, so it cannot be taken down: it expires within the hour. The detail pane says when a copy came down. The server needs the Cloudflare credentials it publishes with (EUROPACORE_CLOUDFLARE_API_TOKENand_ACCOUNT_ID). - Deleting.
dalways asks first, saying what breaks and what stays up. Deleting takes the viewer link and every version, and the server keeps no trash; a published copy stays up unless you tick taking it down too (u, orctrl+uin the typed form), which happens first, so nothing is deleted if it fails. An unpublished artifact deletes ony; a published one once you type the first word of its title, and a repository's heading once you type how many.s(ortabin the typed form) saves the newest version under.europa/artifact-archive/<id>/v<n>/first.
/artifacts <id> opens on that artifact and /artifacts <words> searches; tab completes either. In the prompt, @ offers matching artifacts after the files, and @artifact: only artifacts. The agent's artifact_write and artifact_publish calls draw a card in the transcript with the published link and, for a temporary page, when it expires; its artifact_delete draws one saying the page is gone.
A link opens the page for whoever has it, until it expires or is revoked: treat it as you would a shared document's link. On a europacore from before access, every page has one link that opens it for anyone who has it. ≈tokens are what the runs that wrote each version spent since their previous write, other work included, so they are an upper bound on the page's cost; they and the size need a europacore that reports them, and are left out otherwise. The usage view counts the artifacts the server still keeps, so a deleted one's spend leaves its history; "this repo" needs a europacore that records each version's repository, and an artifact written outside a git repository belongs to none. Needs a europacore server with artifacts (europacore serve, without --no-artifacts).
Runs and evals
/runs lists the runs of all your sessions full screen, newest first, from the server's journal (europacore's GET /v1/runs): each run's status, session, agent, when it started, how long it took, its tokens and cost, and why it stopped (the error, in red, when it failed). Under the list, the selected run's session, input and any hint on what to change.
enterreads the run step by step, as/inspectshows a session's own: each model call's tokens, cache and cost, each tool call with its arguments and result, and anything else that happened in the step.escgoes back to the list.sopens the run's session./runs failed,/runs coderor/runs failed coderfilter by status and agent; on the screenfsteps through the statuses andathrough the agents.- A page holds 50 runs:
m, or↓past the last, reads the older ones.Rreads them again.
It needs a europacore that lists runs across sessions (capabilities.runs_index); on an older one, /runs says so and /inspect still lists the session's own.
/evals lists the eval reports the server keeps (europacore eval writes them into EUROPACORE_EVAL_REPORTS), newest first: whether each passed, its name, how many of its cases passed, its threshold and when it was written. enter (or /evals <id>, which tab completes) opens one: its cases, the failing ones first, each metric's score against the threshold (one score for every metric, or one per metric), and each run's tool calls, answer, rubric verdicts and error. On a server without EUROPACORE_EVAL_REPORTS, /evals says how to set it.
Flows
A flow served by europacore (europacore.graph.register_flow, which makes it an agent like any other) runs in ec like an agent: pick it with -a NAME or /agent.
- The flow's messages show as answers. While a node runs, the editor border names it, and a field the flow streams is written out as it arrives.
- A question waits for your next message. Its quick replies are listed in place of the editor: press
1-9, or use↑↓andenter. Typing anything else answers in your own words. - A form shows one line per field:
tab/↑↓move between fields, andenteron the last field submits. Required fields are checked before it is sent.esclets you answer in words instead (a form node can extract fields from a message), and/approvebrings the form back. - An approval gate before a node uses the approval prompt:
yruns the node,aruns it and skips this gate for the rest of the session, andn/eskip the node (with a reason). - A wait for an external event (
waitnode) shows the event and its deadline:ydelivers it,pdelivers it with a payload (JSON or text), andn/eabandon the wait. - Inside a
parallelormapnode, several children can wait at once: questions, forms, event waits and approvals. The flow asks one of them, and the transcript lists them all once, the asked one marked (5 children of both are waiting; answer them in any order). Each prompt says which child it is for first:Item 2 of draft_cards asks · 1 more waiting(a map's items are counted from 1; a parallel child is named by its node), and the editor border names it (⏸ dog: waiting for your reply · 2 of 5 · alt+w next).alt+wgoes to the next child, in any order, and each is answered as above: a message typed while another child than the asked one is shown goes to that child alone (its reply, or an event's payload), never as a new message the asked child would take. A form whose pause names no fields takes its values typed as a JSON object ({"city": "Oslo"}), and a child's approval is not made from words. The overview's detail says which child asks on aForkline, andec -pwrites it before the pause.
Node failures, rejected gates, delivered events and node-count cut-offs appear as notices.
Options
| Option | |
|---|---|
| Connection | |
| --mock | Run against the built-in mock server |
| --spawn MOD:ATTR | Start europacore serve MOD:ATTR --port 0 and connect to it |
| --server URL | Server URL (env EUROPACORE_URL, default http://127.0.0.1:8765) |
| --token TOKEN | Bearer token (env EUROPACORE_TOKEN) |
| --token-file PATH | Read the token from a file |
| ec login, ec logout, ec workspaces | Sign in to a server that signs people in, out again, and choose the workspace (Signing in) |
| ec settings [list\|set\|unset\|changes] | The server's settings, for its admins (The server's settings) |
| Coding | |
| --code | Work on the current checkout; without --server/--spawn, spawns the coding agent over its repository |
| -w, --workspace DIR | Directory new sessions work in (default with --code: the current one) |
| --worktree | New sessions work in a new git worktree of it, on their own branch |
| --add-repo DIR | Another repository new sessions also work in, as a new worktree on the session's branch there (repeatable) |
| Session | |
| -a, --agent NAME | Agent to talk to (default: the server's first) |
| -s, --session ID | Open an existing session |
| -c, --continue | Reopen the session shown when ec last quit (else the most recent one) |
| --fresh | Don't attach the sessions ec had attached when it last quit |
| -m, --model ID | Model for new sessions |
| --project ID | The project new sessions work in (else their repository's, else the agent's default) |
| Display | |
| --fullscreen | Alternate screen with app-owned scrolling, search (ctrl+shift+f) and mouse; the progress panel becomes a column on the right in a terminal 110 columns or wider |
| --optimum LO-HI | The context-window zone the gauge measures against, in percent, for this run (default 20-60, or "optimum" in ~/.europacore/config.json) |
| --theme dark\|light | Colour theme (default: matches the terminal background) |
| Scripting | |
| -p, --print | One-shot mode (below) |
| --json | With -p: print every event envelope as JSONL |
| --approve, --reject | With -p --session ID: answer the pending decision |
| --form JSON | With -p --session ID: submit a flow's form |
| -h, --help | Show help |
| Environment variable | |
|---|---|
| EUROPACORE_URL | Server URL, used when --server is not given |
| EUROPACORE_TOKEN | Bearer token, used when --token is not given |
| EUROPACORE_SERVE_CMD | Command --spawn runs instead of europacore, e.g. poetry run europacore |
| EUROPACORE_MODEL | Server side: the coding agent's default model (default claude-sonnet-4) |
| EUROPACORE_MODELS | Server side: comma-separated extra models the coding agent allows (see Models) |
Scripting (-p)
ec -p "summarise the open incidents" # answer → stdout, progress → stderr
ec -p --json "…" | jq 'select(.type=="tool-call-start")' # every event envelope as JSONL
some-tool | ec -p --input-format stream-json # each JSON line from stdin a turn of one session
echo "long prompt" | ec -p # prompt from stdin
ec -p --session s_123 --approve # answer a pending decision
ec -p --session s_123 --reject "use the staging db instead"
ec -p -a taps "my tap drips" # a flow: its messages → stdout
ec -p --session s_123 --form '{"name": "Jo", "email": "[email protected]"}' # submit its form
ec -p --session s_123 --approve '{"slot": "9am"}' # deliver the event a wait node expects
ec -p --session s_123 --approve '{"q1": "Postgres", "q2": ["Lint"]}' # answer the agent's questions, by id
ec -p --session s_123 --approve "Postgres, please" # or in wordsExit codes:
| Code | Meaning |
|---|---|
| 0 | Completed |
| 1 | Failed or cancelled |
| 2 | Paused, waiting for a decision, an answer to the agent's questions or (for a flow) a reply, a form or an event. The stderr output says how to answer |
| 64 | Usage error, e.g. --approve without --session, or no terminal for the interactive UI |
| 129, 130, 143 | Stopped by SIGHUP, SIGINT or SIGTERM; the run was cancelled on the server first |
What it does
Streams everything the harness emits.
- Token deltas render as live Markdown with syntax-highlighted code.
- Thinking is folded. While the model thinks, a timer sits over the trace's newest 5 lines, so a long trace neither scrolls the screen nor hides that it is working; once it is done, one line says how long it took:
✻ Thought for 12.3s.ctrl+oshows all of it, with the tool details./foldchanges how it folds (below). - Tool rows show a spinner while running, then ✓, ✗ or ⊘ with the duration.
- The planning tool's checklist is pinned above the editor while its run is live.
Inline decisions. When a guardrail pauses the run, the editor is replaced by a prompt that says what the call will do: the command it runs, the lines an edit changes, the page it fetches, or any other tool's arguments as a list. The agent's prompt is shown too when it adds something, and
ctrl+oshows all of a long call:| Key | Action | |---|---| |
y| Approve | |a| Approve for the rest of the session | |A| Approve always: this exact operation, in later sessions too (shown only when the agent supports it) | |n| Reject | |e| Reject with a reason the agent sees | |esc| Later |- Decisions echo the pause's
pending_tool_call_id, so a stale decision is refused and the prompt re-renders the current pause. - All pause kinds are handled:
approval,code_approval(a code-mode script's call: "A script wants to …"),subagent_approval,policy_escalation,llm_recoverable,unknown_tool_outcome. - A pause that needs a credential shows Connect {service}. For OAuth,
oopens the sign-in page and the run continues on its own once you sign in (yis the fallback). For an API key,ktakes the key (shown as dots), stores it on the server and continues.
- Decisions echo the pause's
Questions. When the agent asks (
coder'sask_user_question, Claude Code'sAskUserQuestion), its questions replace the editor one at a time, each with its options and what they mean.1-9or↑↓andenterpick one; for a question that takes several,spaceticks andenteris done. Typing anything else answers in your own words, in the last "Other" row. With several questions,←→moves between them, and the answers go back together once each has one:✓ Answered — Database: Postgres; Checks: Lint, Tests.escputs the questions aside;/approvebrings them back, and a message you type then answers whatever is left.Images. Paste or drop an image file (PNG, JPEG, GIF or WebP) into the editor, or press
ctrl+vfor the one on the clipboard (macOS;wl-pasteorxclipon Linux), and it is attached to your next message: an[image #1]marker goes where the cursor was, and a⎘line above the editor lists what is attached. Deleting a marker drops its image./image <path>attaches a file,/imagelists the attached images,/image rm <n>drops one and/image cleardrops them all. The agent's limits (how many, how large) are checked before anything is sent, and an agent that takes no images says so. In terminals that show images (Kitty, iTerm2) the messages you sent show them; elsewhere, and after a reload, a[1 image]line stands for them."inlineImages": "off"in~/.europacore/config.jsonturns the previews off. A message with images can't steer a running turn, so it is queued until the turn ends.Documents. On a server that keeps documents (europacore with
EUROPACORE_INDEX_APP_URL), paste or drop any other file (a PDF, a Word or PowerPoint file, Markdown), or/doc <path>, and the agent can search it, read it, rewrite it, or build a deck from a PowerPoint template. It is uploaded at once to your own documents in the Index App and indexed while you write: a[doc #1]marker goes in the message and a▤line above the editor says how far indexing has got. The first upload asks for your Index App API key, never shown./doclists the session's documents,/doc rm <n>removes one and/doc clearleaves them out of the next message; every turn is told the session's documents. A message with documents can't steer a running turn, so it is queued.Projects. On a europacore that keeps projects (
capabilities.projects; itsdocs/projects.md), a session works in at most one project: its members share its memory, its context and its artifacts.--project ID(or/new --project ID) starts new sessions in one; a session in a repository works in that repository's project (owner/repo)./projectsays which the session works in and lists yours with your role, and/project ID(ornone) moves an idle session that isn't in a repository; the header and the footer (▣ henderson) show it./contextlists the project's shared context in the Index App, numbered,/context add <path|url> [--recrawl HOURS]uploads a file or adds a web page, and/context rm <n>removes one; the first time,ecasks for your Index App key. In a message,@context:completes the project's context documents and puts@context:<document id>in the prompt. A server without the Index App says it keeps no project context.A project's coordinator. On a europacore that serves one (
capabilities.project_coordinator, europacore 0.4.0a43; itsdocs/projects.md, "The coordinator"),/coordinatoropens the coordinator of the session's project, and/coordinator IDanother project's: your most recent session with it there, or a new one, which has the project and no workspace. You tell it what the project needs; it starts each piece of work as a request, a fleet session in one of the project's repositories. Before it starts requests, answers one for you or sets the project's settings, it asks, and the approval shows the requests' words, the answer, or the settings and why; these are asked every time, soecoffers no "approve for session"./requestslists the project's requests, newest first, with each one's repository, status and what it needs of you, and/requests Nopens one. A request that waits to start names the requests it waits on and where each stands, with a warning when one failed, since it then never starts on its own; one whose run started without approval, inside what the project's owner approved ahead of time, says so, witheuropacore fleet undo RUNto take it back. The agents are known by their features (coordinator,fleet), not their names.The repository's commands.
/completes the session's commands from the server (.claude/commands/*.md,.europacore/commands/*.md,~/.claude/commands/, and the server's own thatechas none of, such as/mistake) afterec's own, and/helplists them. The server runs them; one typed during a turn waits for it to end.What the server could not set up. The footer says
settings not appliedwhen the server left out some of the repository's Claude Code settings (a notice says which, and whethereuropacore trustapplies them), andMCP 1 failedorMCP 2 to enablefor the agent's MCP servers;/mcplists them and/mcp reconnect NAMEretries one. A turn's closing line counts the calls the permission rules turned down.Nothing hides in a call or the transcript. Escape sequences and control characters from the server, the model or a command's output are dropped before they are drawn, so none can clear the screen, set the window title or hide a link. In an approval prompt they, and bidi overrides and invisible characters, show as markers (
⟨U+202E⟩) with a warning.Notifications. A session that needs you, or a long turn that ends, while the terminal isn't focused asks it for a desktop notification (OSC 9, OSC 99 or OSC 777 where the terminal has one, else the bell).
"notifications"in~/.europacore/config.jsonpicks one or turns them"off".Steering and queueing.
- Typing during a run steers it, using
AgentHarness.steer. alt+enterqueues a follow-up, which is sent when the turn ends.- A steer the run never injected comes back into the editor.
- Typing during a run steers it, using
Runs survive the client.
esccancels a run. Quitting does not: the run keeps going on the server.ec --continueor/sessionsreattaches.- Dropped connections resume with
Last-Event-ID, with no gaps or duplicates.
Footer shows agent, the workspace branch and changed files, model and session, plus a gauge of context-window use against the
