This file documents the security model of Exec Room.
The web room runs Coen (the room lead) and the advisors and makers the owner builds in the room as Claude Code agents, in a local web room (room-server.js, Express) that drives headless claude -p runs. The room can carry out a small set of actions, but only after the owner approves each one.
| Component | Runtime | Exposure |
|---|---|---|
Web room (room-server.js) |
Node.js + Express | 127.0.0.1:4179 only |
Room page (public/) |
Static HTML/CSS/JS, vendored marked + DOMPurify |
Served by the room |
| Agents | Headless Claude Code on the owner's plan | Local processes |
| Deciding from Slack (optional) | Slack's Socket Mode (a connection the server opens out to Slack) and its Web API | Slack: a direct message per card to the approver; only the approver's taps count |
| Approved actions | gh CLI, Notion's own MCP server (through "Connect") or Notion's API (with a token) |
GitHub (the repos each room lists in Room settings; private unless the room marks one as public), Notion (the databases listed in room.config.json, and the pages each room allows) |
npm dependencies: express, marked, dompurify and the Inter font (@fontsource-variable/inter). The last three are copied into public/vendor/, so the page loads nothing from a CDN.
No keys or tokens are committed, and the room stores almost none: the Notion token, an API key and the MCP servers' tokens are read once when the room starts and kept in memory. Two exceptions, both in data/ and both in section 3: an MCP server's token is in a file of its run for as long as that run lasts, and a "Connect" sign-in (its token and renewal key) is kept in data/mcp-signins.json.
Which credentials the room works with
| Credential | Where it comes from | Who gets it |
|---|---|---|
| Claude plan login | Claude Code's own sign-in. A login kept somewhere else (CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CONFIG_DIR) is passed on if set |
claude runs, when the room runs on the plan |
| Anthropic API key | Only when the room is started on a key (see below): ROOM_ANTHROPIC_API_KEY, or a 1Password reference in ROOM_ANTHROPIC_API_KEY_REF |
claude runs, when the room runs on a key |
| Notion token | ROOM_NOTION_TOKEN, or a 1Password reference (notionTokenRef in room.config.json, or ROOM_NOTION_TOKEN_REF) that is read with op read. Without a token the Notion actions are off, unless Notion is connected with "Connect": saving then goes through that sign-in, and the token is used only while the sign-in doesn't work (it can then be taken out of the config) |
The server only. No agent run |
| GitHub login | The gh CLI's own login, or its own variables if set (GH_TOKEN, GITHUB_TOKEN, GH_ENTERPRISE_TOKEN, GH_HOST, GH_CONFIG_DIR) |
gh only, which the server starts. No agent run |
| An MCP server's token | Per server in room.config.json (mcpServers): a 1Password reference (tokenRef) read with op read, or the name of an environment variable (tokenEnv) that is removed once read. Set up on the Exec Room settings page: a 1Password reference, or a "Connect" sign-in kept in data/mcp-signins.json. Never the token itself in a config or on the page |
The server's start-up check and renewals, and the runs of rooms that have that server switched on (see section 3) |
The plan pays, unless the room is started on a key. By default the room never uses an Anthropic API key, so agents bill the owner's Claude plan. Six environment variables would take a run off that plan without anything showing it:
ANTHROPIC_API_KEYandANTHROPIC_AUTH_TOKEN: a key or a token, billed pay-as-you-goANTHROPIC_BASE_URL: another endpointCLAUDE_CODE_USE_BEDROCK,CLAUDE_CODE_USE_VERTEXandCLAUDE_CODE_USE_FOUNDRY: another provider
None of them reaches a run. They are not on the list of what a run is given (next paragraph), the server removes them from its own environment when it starts, and ROOM_PASS_ENV leaves them out even when they are named there. So a key that merely sits in the shell is never used.
What the room passes on to the programs it starts. A program normally inherits every environment variable of the program that starts it, and the server's environment holds whatever the shell it was started from had, tokens of other tools included. So claude runs and gh are not given the server's environment. Each gets a short, fixed list:
- Both get what a program needs to run and reach the network:
PATH,HOME, the user and shell, the temp folder, the terminal type, locale and time zone, proxy and certificate settings, and on Linux the settings folders (XDG_*) and the address of the login keyring. - A
clauderun also gets the two switches that keep Claude Code's own files away from agents (see section 3). On the plan it gets a login token or config folder if one is set; on a key it gets the key and its own config folder. ghalso gets its own variables from the table above.
Tried on 2026-10-13 with Claude Code 2.1.289 and gh on macOS: both still find their login.
Three things add to that list or fall outside it:
ROOM_PASS_ENVis for a setup that needs another variable passed on (a version manager's, say): names separated by commas. Every name in it goes to all agent runs and togh, so name only what is needed. The six variables above andROOM_ANTHROPIC_API_KEYare left out even when named.ROOM_TEST_*: a variable whose name starts withROOM_TEST_is passed on as well. The test suite uses these for its stand-in programs; nothing else belongs in one.op(1Password's command-line program) is the exception to the fixed list: it gets the server's own environment. The server starts it only while the room starts, before any agent runs, and only to read a 1Password reference.
Running on an API key instead. The room can be started on an Anthropic API key, which is pay-as-you-go: npm run room:key (ROOM_AUTH=api-key). The choice is made at start-up and holds until the room stops, so the plan and a key never run side by side, and it is never guessed from a key that happens to be in the environment.
- The key is read once at start-up from
ROOM_ANTHROPIC_API_KEY, or from 1Password throughROOM_ANTHROPIC_API_KEY_REF(anop://reference). Without a key the room does not start. The page has no field for it. - Who gets the key. It is kept in memory and handed to the
clauderuns only. Once it is read, the variable is removed from the server's own environment, so nothing else the server starts afterwards is given it. - Where the key never ends up. It is never written to
data/, the job log or the page. It is also taken out of everything a run sends out before that is shown, saved or passed on: replies (the end of streamed text is held back by a key's length, so a key cut over two pieces is caught), the details of tool calls, proposals and what they become, the transcript, the job log and error text (which is cut to length only after the key is out). A draft file that holds the key is left as the agent wrote it, and is not shown in the room or handed to a next maker; the chat says so. - What taking it out is worth. It is a second line of defence: no way for the key into a run's context is known, as no run has a tool that reads the environment. It has two limits. The match is exact, so a key that is encoded or split on purpose passes. And what an agent sends to the web (a search, a fetched address) has left before the room sees it. That is why the rule that no run gets a shell tool is the protection that counts.
- Its own config folder. With a Claude plan login present, the CLI uses that login and not the key (checked on 2026-10-10 with Claude Code 2.1.289: an invalid key still got an answer, and the run still reported the key as its source). So key-mode runs get
CLAUDE_CONFIG_DIR=data/claude-key, where no plan login exists; a plan token in the environment (CLAUDE_CODE_OAUTH_TOKEN) is not passed on in this mode. Only then is the key what pays, and a wrong key fails. The folder holds those runs' session files; like the rest ofdata/it is git-ignored and unreadable for agents. - No connectors. Notion and Microsoft 365 reading come through the claude.ai connectors of the plan login, so agents have neither of those in this mode, whatever a room's settings say (the settings are kept). Once Notion is connected with "Connect" (section 3), agents in a room with Notion on read it through the Exec Room's own connection instead, with the same three read tools. Notion proposals use that connection or the room's own token, and email drafts use no API, so both still work.
- Linked Notion pages. In this mode only, only while Notion isn't connected with "Connect" (once it is, agents open a linked page themselves), and only in a room with Notion reading on, the server reads the Notion pages linked in the owner's own message (not in briefs or follow-ups the room writes) with the room's Notion token and hands them to Coen as marked, untrusted data, the way linked issues are. At most 3 pages per message, each within fixed limits (400 blocks, 12 requests, 3 levels deep, 30,000 characters); a page's properties are read along with its body, since a database row (a post, say) keeps what it says in them; a link to a database gives how many rows it has (counted, up to 1,000; beyond that "at least"), an overview with one line per row for its 500 most recently edited rows (title, short columns and page id, within 30,000 characters; long text columns are left out and named) and its most recently edited rows in full (at most 25, within 15,000 characters, long values shortened to 1,500 and said to be so), so that counting and filtering across the table works from the overview; a row opened inside a database's view is read as that row; sub-pages and databases inside a page are named, not opened; a page that isn't shared with the room's integration is reported, not guessed at. Agents get no token and no Notion tool, and can't ask for a page themselves. The page text is not written to the transcript or the job log; it is in Claude's own session log of that chat, like anything else an agent is given. Checked live on 2026-10-10 against the real Notion API (two shared pages, a row of a database, that database itself and a page that doesn't exist; the live run showed that Notion answers 400, not 404, for a database asked for as a page).
- Chats don't carry over. A chat's Claude session lives in its mode's config folder, so a chat last used in the other mode starts fresh (the room says so; the history stays).
- Spend caps. One run:
ROOM_RUN_CAP_USD(default 2), passed as the CLI's--max-budget-usd. The CLI checks it after each turn, so a run can pass it by one turn. One day:ROOM_DAY_CAP_USD(default 10), summed from the job log's key-mode lines for this Mac's date and checked before any run starts, including the turns the room starts itself. Job lines without a mode are from the plan and don't count. - What shows it. The page has an "API key" badge, a key-mode run's cost reads as spend (not "equiv."), and each key-mode line in the job log carries
auth: "api-key".
Checked live on 2026-10-10 with a real key and Claude Code 2.1.289: a run through the room, a resumed chat, the per-run cap, and that the key was in no file under data/ nor in the server's output.
CI enforces this: .github/workflows/gitleaks.yml scans the full git history for secrets on every push and PR.
The server binds to 127.0.0.1, rejects requests whose Host or Origin isn't the room itself (DNS rebinding, cross-site requests), accepts only JSON for POST, and sends a strict Content-Security-Policy (default-src 'self', no inline scripts). Agent output is rendered as Markdown through DOMPurify.
Headless runs use --setting-sources project, so the owner's personal pre-approved permissions don't apply. Project settings do load, from the folder the room was cloned into: a .claude/settings.json there with allow rules, or an organisation's managed settings, widens what agents can call; the repo ships none, and agents can't write one (writes under any .claude folder are blocked on every run, see the next paragraph). Agents get read-only tools, Notion read-only, WebFetch only to the sites each room allows (none by default), and Write/Edit under drafts/ only. Anything not allowed is refused, since a headless run can't ask. The hiddenConnectors setting only keeps claude.ai connectors out of the agents' view; it doesn't cover MCP servers the owner has set up locally.
Writes are also blocked by name on every run: nothing under a .claude folder and no CLAUDE.md, anywhere on disk. The allow rules alone weren't enough: Claude Code lets a run edit .claude/launch.json in the folder it starts in without any rule, and that file tells the Claude desktop app which command to start for a preview. Checked live on 2026-10-01 with the room's own flags: without the block that edit went through (and a drafts/CLAUDE.md could be written, which Claude Code may load as instructions for later runs); with the block both are refused, while a normal draft is still written.
A run is given what the room gives it (the agent's own description, the room's note and brief, the message) and nothing of Claude Code's own: every run starts with CLAUDE_CODE_DISABLE_CLAUDE_MDS=1 and CLAUDE_CODE_DISABLE_AUTO_MEMORY=1, so the CLAUDE.md files of this folder, of the folders above it and of any folder an agent works in (this repo's notes for contributors, the owner's personal file, whatever other tools write into such files) and the memory index Claude Code keeps for the folder are not loaded for it, nor for the agents it consults. Without the switches every agent in every room gets them: instructions meant for someone working on the code, and whatever else those files say. The files stay on disk, and an agent can still open one where it may read. Both switches are names from the Claude Code program, not from its documentation, so the room tests them at every start: one small run in a throwaway folder with a CLAUDE.md that holds a random code. If the code comes back, or the CLI reports the memory index as on, the terminal and the page say so. ROOM_CONTEXT_CHECK=off skips the check (the test suite does); the switches are set either way. The owner can turn the whole thing around with "agentsGetClaudeFiles": true in room.config.json: then no switch is set and every agent is given those files, which is a choice to make knowing what they hold.
The page can show a built-in agent read-only (a click on Coen's avatar): GET /api/agents/built-in/<key> returns the description, model and instructions the room loaded from its own agents/ folder at start-up. It reads no file when asked and there is no route that saves one.
The room reads the owner's ~/.claude/agents folder only when the owner imports an agent: the server lists the agent files there (<name>.md or <name>/AGENT.md, up to 200 KB, with frontmatter) and copies the chosen one's name, description, model and instructions into the build form. The name in the request must be a plain file name (no path parts). The copy is saved like any room-built agent, with the role and tools chosen in the room; a tools: line in the file is never read, and later edits to the file don't change the copy. The room never writes to that folder and never runs an agent straight from it.
Every run also passes --permission-mode default, and with it a setting that makes Claude Code refuse to run with its permission checks switched off, whatever asks for that (disableBypassPermissionsMode; tried on 2026-10-12: a run asked to start without checks started without them when the setting was missing, and with them when it was there). The same setting switches hooks off (disableAllHooks): a hook in the project settings of the folder a run starts in is a shell command that Claude Code runs by itself, with the run's environment; tried the same day, such a hook ran in a claude -p without the setting and not with it. On a key no MCP server is started at all (--strict-mcp-config): the connectors belong to the plan login, and each server is a program of its own. Every run blocks, whatever folders its room may read: the room's own data/ folder (every room's transcripts, workspaces.json, the job log, room-built agents); ~/.ssh, ~/.aws, ~/.gnupg, ~/.config, ~/.docker, ~/.kube, ~/.azure and ~/Library, plus the real targets of symlinks inside them; and everything in ~/.claude except the agents' instruction folders (agents, skills, knowledge), again including the real targets of its symlinks (e.g. ~/.claude/projects, every Claude Code session transcript, linked into a synced folder under ~/Dev). Those folders can't be added as room folders either, by the path as typed or by its real path. The instruction folders are always readable, so agents can use their skills and knowledge in any room. Checked live on 2026-09-29: before the fix an agent in a room with no folders could read, grep and list data/; after it, all three are refused.
Connector tools (Notion, Microsoft 365). What an agent can call is decided by an allow list: the three Notion read tools (search, fetch, query a database) when a room has Notion on, and mail search when it has mail on. A run has nobody to ask for permission, so any other tool is refused; tried on 2026-10-13, a read-only Notion tool that is on no list could be loaded and its call was refused ("you haven't granted it yet"). On top of that, tools the room knows are blocked by name so agents don't even see them, and with Notion or mail off the whole connector is blocked. A connector gains tools without notice, and a list of names falls behind (on 2026-10-13 Notion had six the list didn't name, two of them writing). So the room learns: a Notion or Microsoft 365 tool that a run is started with, or tried and was refused, and that is neither allowed nor blocked yet, is written to data/connector-tools.json, said in the chat once, and blocked from the next run on. Until then it is visible and not callable.
The Exec Room's own MCP servers. Next to the claude.ai connectors, the room can start MCP servers of its own, set up in room.config.json under mcpServers. What holds for them:
- Web servers only. A server is a web address:
https, orhttpon127.0.0.1/localhost, with no user name, password, query or fragment in it (a token in an address would end up in logs). An entry withcommandorargs(a program on this computer) is refused: each such server is a program of its own, started with the run's environment. - Read tools only, named in advance. A catalog entry (
mcp-catalog.json) lists the server's tools and marks each as reading or writing; an entry ticks the ones agents may use (tools), and a writing tool on that list refuses the whole entry, since writing goes through the owner's approval and the server, never an agent. A server set up by hand names its read tools inreadOnlyTools. Every other tool of the server, including ones it adds later, is blocked by name or refused because it is on no allow list; one a run reports and the room doesn't know is learned and blocked from the next run on, as for the connectors. - Checked at start-up. The server connects to each one, lists its tools and, for a catalog entry, makes one read call; the terminal and Exec Room settings say "Connected", "No token", "Token not accepted" or "Can't reach the server". A server that isn't connected is given to no run. A tool ticked in the config that the server doesn't have is reported.
- Per room, off by default. A room uses a server only when its "Can use" settings switch it on; rooms saved before this change have none on. The Exec Room settings window can pause a server for every room at once (
data/mcp-servers.json). Room-built agents get the servers only when they have the "mcp" tool group. - The token. It is read once at start-up and kept in memory. For a run, the server writes the servers that run may use, with their tokens, to
data/mcp-runs/<job>.json(folder mode 700, file mode 600) and passes that file's name with--mcp-config, so the token is never on the command line, where other programs on the computer can see it. The file is deleted when the run ends, when the room stops and at every start.data/is blocked for every run, and no run has a tool that reads files outside its rules or the environment, so an agent can't read the token. The page andGET /api/mcpshow where a token comes from, never the token; it is taken out of the check's error text. - One way in per service. In a room with the Exec Room's own server for a service on, the claude.ai connector for that service is blocked (
claudeAiin the catalog), so agents don't reach the same data through two routes with different rules. - On a key the servers still work:
--strict-mcp-configkeeps the claude.ai connectors out and starts only the servers in the run's file.
Checked live on 2026-11-01 in a sandbox, with Claude Code 2.1.316 and a local test server that has two read tools and one deleting tool: the start-up check, the settings window, a room's switch and a real run.
Setting servers up on the Exec Room settings page. Besides room.config.json, a server can be set up on the page: a catalog service from the Popular grid, or a custom server by its web address. The page takes a name, an address and a 1Password reference, never a token or a command. What it adds:
- Saved in
data/. Servers set up on the page are indata/mcp-servers.json(with the pause list). A server inroom.config.jsonwith the same name wins, and the page's one is left out with a line in the terminal. A config server can't be changed or removed from the page. - A token from 1Password is read when the server is set up (1Password asks the owner to approve) and again at each start, like the config's. The server is saved only when its check passes.
- "Connect" signs in with the service the standard way for MCP (OAuth with discovery, self-registration as a public client, PKCE with S256, and a one-time
state). The sign-in opens in a new browser tab and comes back tohttp://127.0.0.1:<port>/api/mcp/callback. A return is accepted only with astatethis Exec Room handed out in the last ten minutes, and each works once; anything else is refused and changes nothing (tried in the suite with a forged and a replayed return). The return is a plain GET from the service's site, so thestateis what ties it to the page, not an Origin header. - Addresses from the service are checked. Where to sign in, register and fetch tokens comes from the server's own answers, so the Exec Room only calls such an address over https, and never one on this computer or a bare IP address (a server could otherwise point it at something local). A server on this computer may only point at this computer (for tests). A name that resolves to a local address is not caught by this check.
- The sign-in is for this server. The token from a sign-in goes to the server that asked for it, so the resource the server names as what the sign-in is for has to be that server: the same origin, with a path its address starts with (RFC 9728, section 3.3). Otherwise Connect is refused. Without this check, a server could name Notion as its resource and Notion's sign-in service as its own; the owner would see Notion's real consent screen, and the Notion token would go to that server. What this check doesn't cover: a server that names its own address but another service's sign-in service. Whether that service then hands out a token that works on its own server depends on that service, so look at where the sign-in tab opens before approving, and add only custom servers you trust.
- The sign-in is kept in
data/mcp-signins.json(mode 600): the token, the renewal key, and where to renew. The renewal key changes at every renewal (Notion's does), so the file is rewritten each time. No run can readdata/, and the page andGET /api/mcpnever show either. Anything running as the owner on this computer can read the file, as it can the rest ofdata/. "Disconnect" removes the server and its sign-in from the Exec Room; ending it on the service's side is done in the service's own settings, which the page says. - Renewal. A timer renews each token ten minutes before it runs out. When the service refuses (the renewal key was revoked, say), the server says "Sign in again" in the terminal and on the page, and no run gets it; a run is also never given a token that has run out. Each renewal is a line in the job log with its time: renewed (and until when), refused (with the service's reason), or failed for another reason such as no network (logged once, tried again every minute). "Too many requests" (429) and a timeout (408) count as such a failure, not as a refusal: a service may limit token requests per internet address, and a network shared with other apps could reach that limit. Such failures go on being tried after the token has run out, for up to a day, since the renewal key usually outlives the token by far: a computer that wakes after its token ran out, before its network is back, keeps the sign-in. Meanwhile the card says "Renewing the sign-in" and no run gets the token. The lines never hold a token or a renewal key. The card says since when a sign-in hasn't been accepted, so it can be set against what happened in the service's own settings.
- Tools. A catalog service set up on the page gets all the tools the catalog marks as reading; the owner can untick some, and a writing tool can't be ticked. A custom server starts with none ticked and gives agents nothing until the owner ticks some. The page shows which tools the server itself calls read-only (MCP's
readOnlyHint), and says that this is the server's own claim: the Exec Room doesn't check it, as for a server added by hand. - What goes to a server and what comes back. What an agent passes to a read tool (a search query, an id) goes to that server's operator, and what the server returns is untrusted: it can carry prompt injection like a web page. Together that is a way out for an agent that was steered by text it read elsewhere: it can put what it read into a tool call. So add a custom server only when you trust its operator with whatever the agents in the rooms that switch it on can read.
GitHub in the catalog. GitHub's MCP server (api.githubcopilot.com) can't be connected with "Connect": its sign-in has no self-registration, and the only permission it offers (repo) reads and writes every private repo. So GitHub is set up with a fine-grained token by its 1Password reference, read-only (Contents, Issues, Pull requests, Metadata) and for chosen repos, at GitHub's read-only address (/mcp/readonly), where its server offers only reading tools (28 on 2026-11-04; the full address adds 18 that write). Agents get 21 of them (code, issues, pull requests, commits, branches, tags, releases, search); left out are the ones about people (the account, teams, collaborators, user search), run_secret_scanning (it sends the text it is given to GitHub) and ui_get. The suite checks that the entry keeps to the read-only address and lists none of GitHub's writing tools. The token decides which repos agents can read, in every room that has GitHub on; a room's own repo list only limits what it may propose. A fine-grained token also reads every public repo on GitHub, whatever repos it was given, so agents can search and read text anyone wrote; in a room with GitHub on they are told to treat it as data, never as instructions. For an organisation's repos the token's resource owner has to be that organisation, and listing branches needs the Contents permission (without it GitHub answers 403, "Resource not accessible by personal access token").
Notion through "Connect". Notion is in the catalog with "Connect" only (https://mcp.notion.com/mcp, Notion's hosted server, the same server and tool names as the claude.ai connector, probed on 2026-11-01). One sign-in does two things:
- Agents read. It isn't switched per room like the other servers: it follows each room's "Notion (read-only)" switch. A room with Notion on gets the connection's three read tools (search, fetch, query a database; the same allow list as for the connector) and every other tool of it is blocked by name; with Notion off nothing of it is in the run. This is the same on the Claude plan and on an API key: once Notion is connected, the claude.ai Notion connector is blocked on the plan, so agents never see Notion twice and there is one way in. Paused, or needing a new sign-in, agents read no Notion at all, on the plan too; they are told so. Not connected, the plan uses the claude.ai connector as before, and a key has links.
- The Exec Room's server saves what the owner approves (section 4) through the same connection, on the plan and on a key, whenever the sign-in works, also while it is paused; a Notion token from
room.config.jsonis used only when it doesn't. The server calls only fetch, create pages and update a page itself, with fields it sets: the agents never get a writing tool. Approving a card doesn't unlock any of Notion's tools: it lets the server do one of its three fixed saves (a draft, a page, an update), only to the places of the room it was proposed in. Notion's other tools (moving or deleting pages, comments, changing a database, its own AI, about 63 of its 68 on 2026-11-02) are used by nobody; the settings page lists them as blocked for agents. - It has the owner's own rights. The sign-in reaches all of the workspace with their rights, where the hand-made integration had only the pages shared with it and no right to update. So what used to be held by the integration's rights is now held by the Exec Room's own rules alone: a row is only ever created with
Status=draftand never changed afterwards (a post whose status changes may be published by an automation the owner runs on that database), a page only goes into one of the room's places or inside one, and only a page the room made can be updated. Whether a page is inside a place is read from the path Notion's server gives with the page, before its properties and text (which whoever edits the page writes); a page whose path doesn't show a place is refused. - Text is sent as text. Notion's server takes a page as Notion's Markdown, which has tags that reach other pages: a sub-page tag that names an existing page moves it, a synced-block reference changes its original everywhere it appears. Every
<in a proposal's text is escaped outside code, so such a tag shows as text and does nothing; the only tag the Exec Room adds is its own grey credit line. A code block without a language is saved as plain text (Notion guessed JavaScript on the probe). - The sign-in opens in the browser. The probe found that the Notion desktop app, if it takes the link over, fails with "Missing or incomplete Client ID"; the page says to copy the link into the browser then.
Every run also blocks secret-looking files anywhere on disk, whatever folders its room reads: .env and .env.*, direnv's .envrc, .dev.vars and .dev.vars.*, *.pem, *.key, *.p12/*.pfx, id_rsa*/id_ed25519*/id_ecdsa*, .npmrc, .netrc, .pypirc, .git-credentials, credentials.json, Terraform's *.tfvars, *.tfvars.json and *.tfstate*, and every .git folder (agents have no git; .git holds remote URLs that can carry tokens, and every old commit). Checked live on 2026-09-29 with fake files: all refused, also under upper-case names (.ENV, SERVER.PEM, .GIT/config), and a Grep over the folder skips them (the patterns added on 2026-09-30 were checked live the same way on 2026-09-30). Blocking by name has a limit: a secret in a file whose name is not on this list (a cloud service-account key saved as my-project-1a2b3c.json, say) can be read inside any folder a room may read, so keep such files out of the folders a room gets. The folder names and patterns here are those of macOS and Linux; the server is not supported on Windows. Without a usable rooms file the default room starts empty, whatever is in the data folder: a fresh install, old chats with no rooms file, or a rooms file that was set aside. The server never gives a room access by itself (until 2026-10-12 an install with chats and no rooms file got the access the code had before rooms could be configured; that code and its lists of sites, repos and Notion pages are gone). A rooms file (data/workspaces.json) that can't be used is moved aside as workspaces.json.broken-<time> and logged with a fixed reason, and the room starts with an empty default room, never the old access; a start that finds such a file and no rooms file (e.g. after a crash between the two steps) does the same. If the file can't be moved aside, the room doesn't start. At start-up the server re-checks every room's stored folders the same way and logs any sensitive one (terminal and job log); it changes nothing, since the blocks already keep such a folder unreadable. Folder entries that aren't text (only possible by editing the rooms file by hand) are dropped when rooms load, logged and saved.
Agents never get Bash or the gh token. That no run has a tool that can run a command or read a program's environment is what keeps the API key, and anything else a run is started with, out of an agent's reach. It is a rule in code, not a side effect of how the tool lists are built: a run or an agent whose list holds anything but Read, Grep, Glob, WebSearch, WebFetch, Agent, ToolSearch, Write and Edit is not started and the chat says why (SAFE_TOOLS), and Bash is in every run's block list as well. The system's own folders (/proc, /sys, /dev) can't be room folders and are blocked on every run; on Linux /proc shows the environment of running programs. When the owner's message links GitHub issues (at most 3) in the room's own repos, the server reads them with gh issue view (fixed arguments, 15s timeout, capped at 20 comments and ~30 KB per issue) and adds them to Coen's prompt as untrusted data between random markers. Links to other repos aren't read; failures are reported to Coen and the owner instead of guessed at.
The owner can attach files to one message (at most 3, 5 MB each; .txt, .md, .csv, .pdf and images only, each checked against its first bytes, stored under a name of letters, digits, - and _; the type is read from the whole name, and only the name shown in messages is shortened). A text file that isn't UTF-8 is refused with its own sentence and never converted: the older encodings can't be told apart, and a wrong character in a file of figures is worse than a refusal. The server saves the files in a folder of their own per job inside the temp folder (exec-room-attachments-<port>), outside the repo and every room's folders, and only that run gets a Read rule for it, on top of the room's access; whoever that run consults can read them too. A run in another chat at the same time, and later turns in the same chat (a revision, a maker, the room's follow-up), get no rule for it. The room only starts when that attachments folder is a real folder, owned by the user running the room, that nobody else can open: its name can be guessed, so where the temp folder is shared between users (/tmp on Linux) a folder or link someone else put there is refused, not used. The job's folder is deleted when the turn ends, whether it finished, failed or was stopped. When the room itself is stopped (Ctrl-C, or SIGTERM), it stops the running agents first and removes their folders once they are gone; a restart removes what a crash left behind. If saving fails, no agent is started and the page gets a plain sentence without the path (the reason is in the job log); if deleting fails, the page says so and names the folder to remove. An attachments folder (this port's or another's), anything inside one and any folder that holds the temp folder are refused as a room folder; a room saved earlier that lists one is reported at start-up (terminal and job log) and that folder is left out of its runs. Checked live on 2026-10-07 with the room's own flags: a file there is refused without the rule and read with it. The agent is told the content is untrusted data. Deleting the file doesn't undo the reading: what an agent read stays in Claude's own session logs (~/.claude/projects) and in Coen's memory of that chat, and whatever an agent quotes lands in the chat transcript or a draft. The chat transcript and the job log themselves keep only the files' names and sizes. A maker dispatched later can't open the file; what it needs has to be in the brief.
A room can carry a brief: what the owner wants everyone working there to know about the business. Only the owner writes it, in Room settings; no agent can propose or change it. It is plain text of at most 3,000 characters with its line breaks kept, and a save is refused (nothing is stripped) when it holds characters that don't show on the page: control characters, a zero-width space, direction marks and overrides. The server adds it to every run in that room and in no other: to Coen's room note, to each advisor's definition for that run and to a maker's note. It is wrapped as background the owner wrote, not instructions, and it changes nothing about what the room lets agents use: tools and blocks are set by the server from the room's settings, never from this text. A chat that was already going keeps the room note it started with, so after a change Coen is told the new brief once, in front of the next message. The brief is stored as plain text in data/workspaces.json, which no agent can read, and it never goes into the job log; but, like everything an agent is told, it ends up in Claude's own session logs (~/.claude/projects), and agents may quote it in replies and drafts. So it is not the place for secrets.
Coen can only propose an action. The owner approves it once on a card; the server then performs it with validated fields — the model never gets the tool:
- Dispatch to a maker — the maker runs with its own definition only, no Agent tool,
drafts/only. - GitHub issue —
gh issue create, only in the room's allowlist of private repos (an issue on a public repo is publishing). - GitHub comment —
gh issue commenton an existing issue, with the same room repo list and visibility check as a new issue (private unless the room lists the repo as public). - Email draft — nothing is sent and no API is called: approving only records the decision, then the card offers Outlook web, mailto and Copy and the owner sends it themselves. A link is only offered while it is short enough to open (Outlook web: 2,000 characters for the whole link, measured against Microsoft's sign-in, which refuses a longer one; mailto: 1,800); beyond that the card says so before approval and Copy is the main button. Every
to/ccaddress must be on the room's recipient list (exact addresses, or bare domains matched exactly), checked when proposed and again on approval; an address with a comma,?,&or a line break is refused, not cleaned up. The job log (jobs.ndjson) only ever has the summary, recipient domains and subject. A draft that is dismissed or sent back for a revision is cut down to those three at once, inrecommendations.jsonand in the chat transcript (the card, and the proposal block and any of its addresses in the proposing message). An approved draft keeps its addresses and text for 7 days, so that it can still be opened or copied after a reload, inrecommendations.jsonand in the transcript's card, both indata/, which no agent can read; the card and Room settings → Decisions offer the links and Copy for that time. It is cut down the same way when the owner clicks "Sent, remove the text" (POST /api/recs/:id/forget) or when the 7 days are over (checked at start-up, every hour, and when the page loads), whichever comes first; a kept draft without a readable date is treated as overdue. Claude's own session logs (~/.claude/projects) and Coen's memory of that chat still have the draft. - Notion page update — replaces the content of a page this room created earlier (known from the link its approval returned; a page written by hand or made in another room can't be named), in a place that is still one of the room's, checked when proposed and again on approval. The new version goes on top and the previous one is kept under it. Through "Connect" the new version is inserted at the top, under a new title, with "Previous version" between it and what was there, which isn't touched: nothing is copied or removed. With a token: nothing is removed before its copy is in place, and a page holding content the room can't copy keeps everything. It needs the integration's "Update content" capability, which in Notion covers everything the integration can reach: the rule that only the room's own pages can be named is what the room adds. Without the capability nothing is touched.
- Save a file — the server writes one new file directly in one of the room's save folders (Room settings → "Folders for saved files", empty by default), from an https link or from a file in
drafts/. Agents still write only todrafts/and get no download tool; they can't open a save folder unless it is also one of the room's read folders.- Which folders. A save folder passes the same checks as a read folder (a real folder, not the home folder or above, not the system's folders, not
~/.ssh,~/.claudeand the other key and settings folders, not the attachments folder), and may not be inside the Exec Room's own code ordata/or inside a.gitor.claudefolder. It is stored by its real path and checked again on approval: a folder taken off the room, or one now leading somewhere else (swapped for a link), saves nothing. - Which links. Only
httpson the standard port, without a user name or password. Addresses on this computer, the home or office network and other non-public ranges (IPv4 and IPv6, including IPv4 inside IPv6) are refused when proposed if the link names one, and on every connection by the address DNS gives: the connection goes to the address that was checked, and every redirect (at most 5) is checked the same way. 25 MB and 60 seconds at most. - Which files. From a link only
.pdf .png .jpg .jpeg .gif .webp .txt .md .csv .json .docx .xlsx .pptx, and the content must be that type (a web page sent in place of a file, such as a sign-in page, is refused under every extension). Nothing that runs: a file the server saves has no macOS "downloaded from the internet" flag, so a program saved this way would open without that warning. A draft is copied as.md, or turned into a Word file that the server builds itself (docxFromMarkdown, the same on every system; no other program runs). Nothing is fetched while building it: raw HTML in the draft stays text, an image becomes its description, and links become clickable only forhttp(s)andmailto. Only a plain file indrafts/itself, not a link. - Never overwrites. The file is created with
O_EXCLandO_NOFOLLOW, so an existing file or a link in its place is never written through; a taken name gets " (2)" and so on. Names that tools act on by themselves (CLAUDE.md,AGENTS.md, env and key file names) are refused; a leading dot (a hidden file) is dropped, and so are path parts and characters macOS or Windows don't allow in a name. - For the suite only:
ROOM_TEST_SAVE_HOSTlets downloads use one plain-http address on this computer (the suite's pretend file server). The room says so at start-up whenever it is set; never set it for a real room.
- Which folders. A save folder passes the same checks as a read folder (a real folder, not the home folder or above, not the system's folders, not
- Notion draft — only in the room's own Notion databases (Room settings → Can propose → "Notion databases"), and only in one with a draft column: the status or select column, and its value, chosen for that database when it was added (
Status = draftfor databases listed inroom.config.jsonbefore, which move into the rooms that allowed them). The server always sets that value itself; an agent never chooses it. What the integration can write beyond that is decided by what the owner shares with it in Notion; the server only ever creates rows with the draft value and has no action that changes a row.- Adding a draft column is the only change the Exec Room makes to a database's columns: "Add a Status column with Draft", only when the owner clicks it in Room settings, through Connect only (
ADD COLUMN "Status" STATUS('Draft', 'Done'), or "Draft status" when a column named Status already exists). It never removes or changes a column. - A database's columns are read from Notion when it is added (never taken from the page) and, for databases without columns or a draft value yet, again when Room settings open. A database Notion can't describe says why on its row.
- Adding a draft column is the only change the Exec Room makes to a database's columns: "Add a Status column with Draft", only when the owner clicks it in Room settings, through Connect only (
- Notion row — a row in one of the room's Notion databases with a draft column, up to 5 per proposal. Each column has a rule, chosen per database in Room settings: agent fills (the agent proposes the value, shown on the card), always this value (the server sets the value chosen there, on every row) or leave empty. Defaults: the title, text and links are the agent's, the draft column is always the draft value, the rest is empty; a column added in Notion later stays empty until the owner chooses. A status column is never "agent fills" (status columns are what automations watch, such as one that posts a row once its status changes), and columns the room can't fill (people, relations, files, formulas) are always empty.
- Every value is checked against its column's type (an option of a select, a date, a number, an http(s) link, an email address) when proposed, and again on approval against the database as Notion describes it then: a column or option removed in the meantime, or a fixed or draft value that no longer fits, saves nothing. A column the agent may not fill is refused, not dropped.
- Posts (notion_draft) follow the same rules: a post column set to always or empty gets that, and a database whose Channel or Post Content isn't the agent's can't take posts.
Posting, scheduling, sending messages and deploying can't be proposed at all.
Deciding from Slack (optional, off until slack is set in room.config.json). Each new card is also sent to the owner as a Slack direct message with Approve, Dismiss and a link to the room; a tap there is decided by the same code as the card's own buttons (approveRec, dismissRec), with the same checks on approval. Revise needs a written note and stays on the page.
- Nothing listens. Taps come in over Slack's Socket Mode: the server opens a connection out to Slack (TLS, with the app-level token) and Slack sends taps down it. The room still answers only on
127.0.0.1. - Who decides. Only a tap whose Slack member ID is the
approverinroom.config.jsoncounts; any other is refused and noted in the terminal. Decisions made in Slack carryvia: "slack"on the proposal, its log line and its decision event, and the page and Decisions list say "in Slack". - What goes to Slack. The card's kind, who proposed it, the room, the chat's name, the summary and its target (the maker, repo, Notion database, page title, email recipients, file path or new agent's name), and after a decision its outcome and result links. Never a brief, a draft, an issue's text or an email's text. Text an agent wrote is escaped (
&,<,>), so it can't mention people or channels or make links in Slack. Slack keeps what it is sent. - The tokens. A bot token (
chat:write,im:write: it messages the approver and updates those messages) and an app-level token (connections:write), read from 1Password at start-up and kept in memory, like the Notion token. No run or agent gets them; the page only ever learns that Slack isn't connected, and why. - One room per Slack app. Slack hands each tap to one of the app's open connections, so a second room connected to the same app would take taps meant for the first. A room on another data folder (
ROOM_DATA_DIR) only connects withROOM_SLACK=on;ROOM_SLACK=offkeeps any room off.ROOM_SLACK_APIis for the test suite's pretend Slack; never set it for a real room, as the tokens would go to that address.
Chats, proposals and the job log live in data/, which is gitignored.
GET /api/workspaces/:id/decisions (Room settings → Decisions) reads the job log back to the page, read-only: one row per decided proposal in that room across its chats, with who decided, the action and summary, when, the outcome, and the links or draft names it produced. Two things on a row come from outside the log: which agent proposed it (from the stored proposal) and the title of the chat it came up in (the start of that chat's first message, with any email address in it cut down to its domain). It sits behind the same Host and Origin checks as every other route and adds no login: the name it shows is the room's one owner (ownerName in room.config.json, or "the owner"), which says whose room this is, not who was at the keyboard. What the owner wrote with a decision is on its row: the reason for a dismissal (optional) and the note for a revision. An email draft is the exception: it shows only its subject and the recipients' domains (all the log ever kept), and a reason or note on it is held back, because it may quote the draft whose addresses and text were removed; the row only says that one was given. Decisions from a chat whose room was deleted are in no room's list. The page turns a result into a link only when it passes the same address checks as the proposal card (a Notion page, or a GitHub issue or comment). Agents can't call it: they have no Bash, and a room's sites can't be localhost or an IP address.
A room's id is given out once. A deleted room's chats stay in the chat index (data/rooms/index.json) under its id, so a new room never gets the id of a room that exists or of one a chat still names: it would otherwise take over those chats, their decisions and any proposal still open in them, under its own members and access (and with a live room's id it would replace that room). Nothing extra is stored for this: the chat index is the record of used ids.
Every chat is kept: its transcript in data/rooms/ and its record in the chat index. The page lists a room's chats so the owner can go back to one; only chats whose room still exists can be opened, and a chat id in a request is only ever looked up in the index, never used as a path. The owner can give a chat a name (one line, at most 80 characters, invisible characters refused); the name is stored in the index only, is not told to any agent and is not written to the job log. Going back to a chat changes nothing about what its room allows: the room's current settings apply. Coen's own memory of a chat is Claude Code's session log, which Claude Code removes about 30 days after the chat's last message; the list marks such a chat "history only", and a message there starts Coen fresh, which the chat says.
GitHub Actions run on every push and PR to main:
- Gitleaks (
gitleaks.yml) — secret scan of the full history - Trivy (
trivy.yml) — fails on unfixed CRITICAL CVEs; also weekly on Mondays - Pin actions (
pin-actions.yml) — third-party actions must be pinned to a commit SHA - Gitleaks version check (
gitleaks-version-check.yml) — monthly PR when a newer Gitleaks is out - CLA (
cla.yml) — on pull requests, checks that the person who opened it and every commit author has signed the contributor agreement inCLA-SIGNATURES.md. It runs frommainalso for pull requests from forks (pull_request_target), so a pull request can't change the check; it has a read-only token, no secrets, no checkout and no shell step, and reads the pull request only as data
Dependabot (.github/dependabot.yml) keeps GitHub Actions and the npm packages up to date weekly (after a marked or dompurify update, re-copy its browser build into public/vendor/). Changes to main go through pull requests.
If you discover a security issue, please report it privately through GitHub's Report a vulnerability button on this repository's Security tab, rather than opening a public issue.