npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@markmo/europacore-cli

v0.4.11

Published

Terminal UI for europacore agents, speaking the europacore server API (europacore/docs/server-api.md)

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 · mock

The 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 server

Quick 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 in

Coding 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+o shows all), and commands show their exit status, with the end of their output when they fail.

  • Claude Code. With europacore's claude-code extra (pip install 'europacore[claude-code]') and a logged-in claude, the coding server also serves the claude-code agent: Claude Code running its own agent loop in the same checkout. ec --code -a claude-code starts one, and /agent claude-code starts one beside the sessions you have. Streaming, diffs, approvals (a keeps 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 for coder. 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_MODE sets which tools ask (default acceptEdits: edits go through, commands ask), and EUROPACORE_CLAUDE_MODEL picks the model (sonnet, opus, haiku). The rest are in europacore's docs/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).

  • /changes lists the changed files; /diff [path] shows the diff against HEAD.

  • Pull requests. A pull request coder opens 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. /pr lists them, /pr follow <url> adds one opened elsewhere, /pr unfollow stops it, /pr open opens 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 · /tasks

    The branch, path and uncommitted changes come from the server. The remote, upstream, Session (what changed since the session started, committed or not) and Commits (made since it started) come from git on this machine, so they show only when its checkout is at the workspace's commit, as with ec --code. Task worktrees and added directories show when there are any.

  • @path completes 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, so ec --code -c reopens the last session after ec (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. /tasks lists 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; /tasks counts 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 stop stops it.

  • A new worktree's setup (setup in .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_MODEL sets the default model. If it is not set, the default is claude-sonnet-4.
  • EUROPACORE_MODELS is 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:

  1. --mock runs the built-in mock server.
  2. --cloud [TARGET] connects to the cloud server europacore cloud login saved (default unless named), with its token.
  3. --spawn MOD:ATTR starts europacore serve MOD:ATTR --port 0 and reads its ready line. Set EUROPACORE_SERVE_CMD to change the command, e.g. poetry run europacore.
  4. --server / EUROPACORE_URL connects to a running server. The default is http://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 login keeps 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 which ec says to sign in again.
  • A provider. With a provider, ec opens 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 leaves ec. EC_BROWSER=none prints the link instead of opening it.
  • Scripts. --email and --password-stdin sign 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 server

ec 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. /new starts another one and /sessions <id> (or /resume) attaches an existing one; the session you were in stays attached. alt+. and alt+, 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+s or esc zooms 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. enter opens the highlighted session, attaching it if need be. s changes the order, d detaches and r refreshes the list (it also follows the server's session feed as sessions change, or refreshes every 2 seconds on a server without it). tab switches to the inbox and back; space opens a fleet's tasks under its row; b shows the board.
    • Peek. → (or l) 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: enter sends 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. esc goes back to the list, keeping the decision and anything typed. A session that is only listed is attached out of view first.
    • Starting sessions. n opens a line for a new session's prompt: enter starts it here, out of view, and puts the cursor on its row, so several can be started in a row and enter opens one. An empty line opens a new session, as n did before.
    • Filter, pin, rename. / filters the rows as you type, on titles, agents, models, workspaces and branches; a:NAME matches the agent, s:STATE the status or stage (s:waiting, s:review) and p:PROJECT the project (p:none: in none). enter keeps the filter (shown in the header), and esc clears 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. e renames 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|clear sets one while it is idle. The progress column shows a plan's steps (plan 2/4) or a fleet's tasks (3/5 passed).
  • Board. alt+k (or /board, or b in 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+k or esc goes 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, and enter opens the card. A fleet task's keys work as they do in the overview (o x R t p i m). c shows 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). enter opens the session with that decision in front of you; a finished row leaves the inbox once opened, or with m.

  • Order. s in 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.json says otherwise; --optimum 30-70 changes 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 ⏸2 suffix 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 --fullscreen in 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-writer

    In 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. /recap asks 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 ☁. /claims lists 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, ec watches 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 offers h (hold until they are done) and t (leave the file to them). The same directory is a softer warning.

  • 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's docs/rules.md). When the server has drafted one, the session says Rule offered: You marked a mistake — /rules to decide, and the overview, the board and the inbox show Rule offered. /rules lists the repository's offers, numbered, each with its draft (deny or ask, 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, and Retire? 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, match one 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 /undo with files, or a /mistake; its offer says Changed: <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 says Writing a test… with no actions; ec doesn't poll, and the next /rules reads how it went: a test that passed is listed under Tests written as w1, w2… with its branch, and one that didn't is open again with The 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 /rules stops 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 /rules lists under Tidy as t1, t2… (Merge, Covered, Never asks, Group, each with why): it asks, rewrites the file, and lists the rules as they now stand;
    • /rules draft drafts the mistakes that have no offer yet, within the day's improvement budget.

    A server with improvement turned off keeps no learned rules, and /rules says so.

  • Letting go. /detach [id] (or d in 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; ec still opens on a new session, and ec -c opens 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. --fresh starts 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.toml starts a fleet session and sends it the spec (/fleet with 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+w shows the next, and the inbox lists them all. Each is answered like any other decision.
  • /cancel TASK (or all), /retry TASK [note] and /steer TASK TEXT command the run; other text goes to every running task. /review TASK says where a task is and why.
  • In the overview, enter on a task opens its worker's session, read-only and live: its decisions are answered there through the fleet, typing steers the task and /cancel cancels it. o opens 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 pr opens 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; enter adopts one into a fleet session.
  • /fleet with 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, ⇄ integration shows the fleet's integrator; enter on it, or i on 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> (or variants/best_of in 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. p picks the one to merge, /pick <variant> does it directly, and p on a variant's row in the overview compares at any time. t tries a variant: a shell in its worktree, to run the app on its changes, while your checkout stays as it is (exit comes back; c copies a cd there instead). t on any fleet task's row, and /shell in any session, do the same.
  • /accept fast-forwards the base branch to a completed run's merged work, and /undo takes the run back (its work is kept under refs/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:

  1. You record them. /decision <text> [-- why] and /requirement <text> [-- why] (/dec, /req). The reason goes after --.
  2. 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].
  3. The agent marks them. Lines in an answer that start with Decision: or Requirement: (bullets and bold allowed), and the bullets under a ## Decisions or ## Requirements heading, are remembered as the answer finishes. A sub-bullet starting rationale: or why: gives the reason.
  4. You ask the agent. /decisions extract asks it to list the decisions and requirements agreed so far. A checklist of the new ones replaces the editor: space unticks one, a ticks all or none, enter keeps the ticked ones and esc drops 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, or a 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. p pins the selected memory, or unpins it, after asking why (optional; enter with nothing sends no reason, esc sends 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. Needs capabilities.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 under Links; 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 under Linked from, and says when a page's index line stands for its own. In a memory's view, tab and shift+tab pick a linked memory, enter opens it, and esc goes back to the memory it was opened from; the header shows the way you came (billing-deploys › deploy-day). A page is edited as type: page, with a body of up to 12,000 characters; a bloated page is longer than the notes it links.

  • Changes.

    • e edits the memory in $VISUAL or $EDITOR as 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 next e reopens it.
    • f forgets a memory, r restores it, and h shows 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 (◌).

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). tab steps 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 with artifact_read; o opens and y copies the link (the published page while it is up, else the viewer page); Y copies a temporary page's claim link; v lists the versions to open or copy one; r opens the session that made it.
  • Kept current. What the sessions attached to this window write, publish or delete shows while the screen is open; R reads the list again for the rest.
  • By repository. g groups 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, A and U take its artifacts, and r opens a session's; a repository's d asks for their count typed.
  • The ledger. t, or /artifacts --table: sortable columns (s the next, S reverses), space ticks a row and a ticks 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; w widens the window (4, 8, 12 or 26 weeks); p counts only the shown session's repository; c opens the ledger on the untouched ones, oldest first, and s on the stale ones; X exports 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_CHROME names 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): o and y get 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, with p to make it private instead.
  • Taking a published copy down. U takes down the copy artifact_publish put 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_TOKEN and _ACCOUNT_ID).
  • Deleting. d always 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, or ctrl+u in the typed form), which happens first, so nothing is deleted if it fails. An unpublished artifact deletes on y; a published one once you type the first word of its title, and a repository's heading once you type how many. s (or tab in 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.

  • enter reads the run step by step, as /inspect shows 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. esc goes back to the list.
  • s opens the run's session.
  • /runs failed, /runs coder or /runs failed coder filter by status and agent; on the screen f steps through the statuses and a through the agents.
  • A page holds 50 runs: m, or ↓ past the last, reads the older ones. R reads 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 ↑↓ and enter. Typing anything else answers in your own words.
  • A form shows one line per field: tab/↑↓ move between fields, and enter on the last field submits. Required fields are checked before it is sent. esc lets you answer in words instead (a form node can extract fields from a message), and /approve brings the form back.
  • An approval gate before a node uses the approval prompt: y runs the node, a runs it and skips this gate for the rest of the session, and n/e skip the node (with a reason).
  • A wait for an external event (wait node) shows the event and its deadline: y delivers it, p delivers it with a payload (JSON or text), and n/e abandon the wait.
  • Inside a parallel or map node, 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+w goes 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 a Fork line, and ec -p writes 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 words

Exit 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+o shows all of it, with the tool details. /fold changes 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+o shows 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, o opens the sign-in page and the run continues on its own once you sign in (y is the fallback). For an API key, k takes the key (shown as dots), stores it on the server and continues.
  • Questions. When the agent asks (coder's ask_user_question, Claude Code's AskUserQuestion), its questions replace the editor one at a time, each with its options and what they mean. 1-9 or ↑↓ and enter pick one; for a question that takes several, space ticks and enter is 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. esc puts the questions aside; /approve brings 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+v for the one on the clipboard (macOS; wl-paste or xclip on 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, /image lists the attached images, /image rm <n> drops one and /image clear drops 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.json turns 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. /doc lists the session's documents, /doc rm <n> removes one and /doc clear leaves 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; its docs/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). /project says which the session works in and lists yours with your role, and /project ID (or none) moves an idle session that isn't in a repository; the header and the footer (▣ henderson) show it. /context lists 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, ec asks 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; its docs/projects.md, "The coordinator"), /coordinator opens the coordinator of the session's project, and /coordinator ID another 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, so ec offers no "approve for session". /requests lists the project's requests, newest first, with each one's repository, status and what it needs of you, and /requests N opens 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, with europacore fleet undo RUN to 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 that ec has none of, such as /mistake) after ec's own, and /help lists 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 applied when the server left out some of the repository's Claude Code settings (a notice says which, and whether europacore trust applies them), and MCP 1 failed or MCP 2 to enable for the agent's MCP servers; /mcp lists them and /mcp reconnect NAME retries 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.json picks one or turns them "off".

  • Steering and queueing.

    • Typing during a run steers it, using AgentHarness.steer.
    • alt+enter queues a follow-up, which is sent when the turn ends.
    • A steer the run never injected comes back into the editor.
  • Runs survive the client.

    • esc cancels a run. Quitting does not: the run keeps going on the server.
    • ec --continue or /sessions reattaches.
    • 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