🔌 Claude Code plugin & hooks

The plugin connects Claude Code to the Codelux AI daemon on your machine: the MCP server with the 8 tools, three slash commands, and five hooks that make memory and the file lock happen without the model having to remember to call anything.

Install

Or inside Claude Code: /plugin marketplace add codeluxai/codelux, then /plugin install codelux@codelux. The hooks need bash and curl (on Windows, Git Bash). If the daemon is not running every hook is silent — Claude Code works as if the plugin were not there.

The five hooks

The AGENTS.md / CLAUDE.md block

At every session start and every memory_set, Codelux AI rewrites the block between <!-- codelux:start --> and <!-- codelux:end --> in <project>/AGENTS.md (created if missing) and, when the file exists, in <project>/CLAUDE.md: status, next step, traps and recent decisions, at most 60 lines. Text outside the markers is never touched. Agents that read no hooks still read this file.

Slash commands

Codex and Gemini CLI (experimental)

The same scripts run from any agent that supports command hooks. The plugin folder ships two ready-made files: hooks/codex.hooks.json for Codex (copy to <repo>/.codex/hooks.json) and hooks/gemini.settings.json for Gemini CLI (merge its hooks object into <repo>/.gemini/settings.json). The MCP server is the same URL for every agent. What the hooks do not carry, the AGENTS.md block does.

🤖 Set up your AI agent

Codelux AI reaches every agent through two channels: the MCP server (the tools) and the hooks (what happens without the model having to ask). Below is the complete, copyable configuration for each provider.

What the hooks give you

The whole procedure, step by step

The providers' apps must have the Codelux hooks active: the main session and its subagents send everything. With the hooks on every tool (PreToolUse + PostToolUse + PostToolUseFailure for Claude Code, PreToolUse/PostToolUse for Codex, BeforeTool/AfterTool for Gemini CLI) Codelux records one row per tool call, native or Codelux, for the session and for each subagent, under the agent's name.

What a row holds: provider, session or subagent, tool, the essential arguments (Read: file and lines; Grep/Glob: pattern, path, glob; Edit/Write: file and lines or bytes touched; Bash: the command cut to 200 characters; Agent: type and description; MCP: tool and key arguments), the size of the response in bytes and lines, the duration and the outcome. Never a file's content, an output or the text of an edit; keys, tokens and passwords in commands and arguments become [redacted]. Everything stays on your machine (the project's local store, 30 days): nothing is sent to the server, nothing goes into the Team's events.

The app's Procedure view (per project, per agent, per day) shows the sequence with times, the files read again although unchanged, the big files read whole when one symbol was enough, the share of Codelux calls, the tokens estimated per read and the rounds that could be saved, with the concrete alternative (code_context X instead of 2,000 lines). Export it as Markdown, or read it with GET /api/project/{id}/procedure?from=&to=&who=&format=md or codelux procedure <projectid>.

Hints to the running agent: only when the saving is clear, one sober line in its context ("you already read X at 10:59 (lines 1-200) and it has not changed since", "X is an indexed symbol: code_context X"), at most 2 a turn, never blocking. They can be turned off per project in the Procedure view.

Reading only what is needed: GET /api/project/{id}/read?file=&from=&to= (REST), codelux read <projectid> <file> <from> <to> (CLI) and, on MCP, code_context with name="<file>:<from>-<to>" answer the lines asked (at most 400), numbered, with the file's total, the estimated tokens and the next range; code_context name="<file>" answers the file's outline (symbols with their lines). Every Codelux read is in the same Procedure.

At a glance

Before you start

• Codelux AI is running and the project is added in the app. The MCP address is http://localhost:8766/mcp; if Codelux AI runs on another port, use yours.
• The hooks need bash and curl; on Windows, Git Bash.
• Codex and Gemini CLI: get the plugin folder from github.com/codeluxai/codelux and, in the files below, replace CODELUX_PLUGIN with the full path of the folder that holds scripts/. On another port, start the agent with the variable CODELUX_PORT set.

The AGENTS.md block

Every agent reads the same block between <!-- codelux:start --> and <!-- codelux:end -->: a few fixed lines saying which Codelux AI tools to use and that the memory arrives by itself or with memory_get. It carries no date and no status, so it is identical in every session and does not invalidate the provider's prompt cache. The session-start hook keeps it up to date; without hooks, run this once from the project folder:

It creates AGENTS.md with the block when missing (and CLAUDE.md with the single line @AGENTS.md); text outside the markers is never touched. If the folder is not a project registered in Codelux AI, nothing is written.

Claude Code

Full support. The plugin brings everything: the MCP server, the hooks and the slash commands. There is nothing to copy by hand.

1. Install the plugin:
   claude plugin marketplace add codeluxai/codelux claude plugin install codelux@codelux
   or, inside Claude Code, /plugin marketplace add codeluxai/codelux and then /plugin install codelux@codelux. On another port: claude plugin install codelux@codelux --config port=<port>, then restart Claude Code.
2. Restart Claude Code in the project folder and type /codelux:status to check that it is connected.
3. Instruction file: at session start the plugin writes the block in AGENTS.md and, if CLAUDE.md does not exist, creates it with one line that imports it. An existing CLAUDE.md that does not import AGENTS.md gets the block appended.
   @AGENTS.md
4. Hooks: the file is hooks/hooks.json inside the plugin, already wired. This is the part that takes and releases the lock (the other hooks are in Claude Code plugin & hooks):
   "PreToolUse": [ { "matcher": "Edit|Write|MultiEdit|NotebookEdit", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/edit-lock.sh\" acquire", "timeout": 10 } ] } ], "PostToolUse": [ { "matcher": "Edit|Write|MultiEdit|NotebookEdit", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/edit-lock.sh\" release", "timeout": 10 } ] } ], "PostToolUseFailure": [ { "matcher": "Edit|Write|MultiEdit|NotebookEdit", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/edit-lock.sh\" release-failed", "timeout": 10 } ] } ]
   And the part that sends the procedure (every tool, matcher .*):
   "PreToolUse": [ { "matcher": ".*", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/session-track.sh\" pre", "timeout": 5 } ] } ], "PostToolUse": [ { "matcher": ".*", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/session-track.sh\" post", "timeout": 5 } ] } ], "PostToolUseFailure": [ { "matcher": ".*", "hooks": [ { "type": "command", "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/session-track.sh\" post-fail", "timeout": 5 } ] } ]
5. MCP: the plugin registers the server codelux. Without the plugin, see IDE Setup (MCP).

Codex

Experimental. The hooks format comes from Codex's documentation of 28/09/2026; a few fields are not confirmed (see below).

1. Add the MCP server in Codex's configuration, ~/.codex/config.toml:
   [mcp_servers.codelux] url = "http://localhost:8766/mcp"
   This form is taken from Codex's MCP documentation and not verified by us on every version: if Codex does not list the tools, check the exact syntax there.
2. Instruction file: AGENTS.md. The block is written by the session-start hook, or by hand with the command above.
3. Copy this file to <project>/.codex/hooks.json (or to ~/.codex/hooks.json for every project), replacing CODELUX_PLUGIN:
   { "description": "Codelux hooks for Codex. Copy to <repo>/.codex/hooks.json (or ~/.codex/hooks.json) and replace CODELUX_PLUGIN with the absolute path of the folder that holds scripts/. Same scripts as the Claude Code plugin; plain stdout is added as context, exit 2 on acquire blocks the edit with the stderr reason. PreToolUse/PostToolUse on every tool (.*) feed the procedure trace (377). See hooks/OTHER-AGENTS.md for the fields we could not verify.", "hooks": { "SessionStart": [ { "matcher": "startup|resume|clear|compact", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-start.sh\" --agent=codex", "timeout": 10, "additionalContextLimit": 12500 } ] }, { "matcher": "startup|resume|clear|compact", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" start --agent=codex", "timeout": 5 } ] } ], "UserPromptSubmit": [ { "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/prompt-memory.sh\" --agent=codex", "timeout": 5 }, { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" prompt --agent=codex", "timeout": 5 } ] } ], "PreToolUse": [ { "matcher": "Edit|Write|MultiEdit|apply_patch", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/edit-lock.sh\" acquire --agent=codex", "timeout": 10 } ] }, { "matcher": ".*", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" pre --agent=codex", "timeout": 5 } ] } ], "PostToolUse": [ { "matcher": "Edit|Write|MultiEdit|apply_patch", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/edit-lock.sh\" release --agent=codex", "timeout": 10 } ] }, { "matcher": ".*", "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" post --agent=codex", "timeout": 5 } ] } ], "Stop": [ { "hooks": [ { "type": "command", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" stop --agent=codex", "timeout": 5 } ] } ] } }
4. Restart Codex.

Not confirmed

• The names of the edit tools: the documentation's example is Edit|Write (file edits through apply_patch); we match Edit|Write|MultiEdit|apply_patch to be safe.
• The field that carries the edited path for apply_patch. The script looks for file_path, notebook_path or path; if Codex sends only the patch text, the lock does nothing (it never blocks).
• The unit of timeout (we assume seconds) and a project-folder variable (the scripts use the working directory, or CODEX_PROJECT_DIR if set).
• Whether Codex sends a session_id to the hooks. Without it the session tracking is skipped, and the MCP calls get one code per connection.

Gemini CLI

Experimental. The hooks format comes from Gemini CLI's reference of 28/09/2026; a few fields are not confirmed (see below). Everything goes in <project>/.gemini/settings.json (or ~/.gemini/settings.json).

1. Add the MCP server:
   { "mcpServers": { "codelux": { "httpUrl": "http://localhost:8766/mcp" } } }
   This form is taken from Gemini CLI's MCP documentation and not verified by us on every version: if the tools do not appear, check the exact syntax there.
2. Instruction file: Gemini reads GEMINI.md, not AGENTS.md. Either point it at AGENTS.md in the same settings file, or copy the block into GEMINI.md:
   { "contextFileName": "AGENTS.md" }
   The setting is called contextFileName in our plugin notes; if your version of Gemini CLI names or nests it differently, check its settings reference.
3. Merge this hooks object into the same file, next to the keys above, replacing CODELUX_PLUGIN. The scripts run with --json because Gemini wants only JSON on stdout:
   { "hooks": { "SessionStart": [ { "hooks": [ { "type": "command", "name": "codelux-memory", "description": "Codelux: project memory in context at session start; refreshes the AGENTS.md/GEMINI.md block", "command": "bash \"CODELUX_PLUGIN/scripts/session-start.sh\" --json --agent=gemini", "timeout": 10000 } ] }, { "hooks": [ { "type": "command", "name": "codelux-session", "description": "Codelux: session code and usage tracking (silent)", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" start --agent=gemini", "timeout": 5000 } ] } ], "BeforeAgent": [ { "hooks": [ { "type": "command", "name": "codelux-prompt-memory", "description": "Codelux: relevant memory for this prompt as additionalContext (nothing when nothing is found)", "command": "bash \"CODELUX_PLUGIN/scripts/prompt-memory.sh\" --json --agent=gemini", "timeout": 5000 }, { "type": "command", "name": "codelux-session-prompt", "description": "Codelux: count the prompt; rarely one hint about the last turn", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" prompt --json --agent=gemini", "timeout": 5000 } ] } ], "BeforeTool": [ { "matcher": "write_file|replace|edit", "hooks": [ { "type": "command", "name": "codelux-lock-acquire", "description": "Codelux: take the file lock (local + Team) before an edit; exit 2 with the reason when refused", "command": "bash \"CODELUX_PLUGIN/scripts/edit-lock.sh\" acquire --agent=gemini", "timeout": 10000 } ] }, { "matcher": ".*", "hooks": [ { "type": "command", "name": "codelux-session-pre", "description": "Codelux: start of every tool call for the procedure trace, file read (path+hash), MCP call announcement; rarely one hint as additionalContext", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" pre --json --agent=gemini", "timeout": 5000 } ] } ], "AfterTool": [ { "matcher": "write_file|replace|edit", "hooks": [ { "type": "command", "name": "codelux-lock-release", "description": "Codelux: release the file lock after an edit", "command": "bash \"CODELUX_PLUGIN/scripts/edit-lock.sh\" release --agent=gemini", "timeout": 10000 } ] }, { "matcher": ".*", "hooks": [ { "type": "command", "name": "codelux-session-post", "description": "Codelux: one row of the procedure trace (tool, essential arguments, response size, duration; never contents)", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" post --agent=gemini", "timeout": 5000 } ] } ], "AfterAgent": [ { "hooks": [ { "type": "command", "name": "codelux-session-stop", "description": "Codelux: read the new usage numbers (silent)", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" stop --agent=gemini", "timeout": 5000 } ] } ], "SessionEnd": [ { "hooks": [ { "type": "command", "name": "codelux-session-end", "description": "Codelux: close the task and write the usage report (silent)", "command": "bash \"CODELUX_PLUGIN/scripts/session-track.sh\" end --agent=gemini", "timeout": 10000 } ] } ] } }
4. Restart Gemini CLI.

Not confirmed

• SessionStart does not list additionalContext among its fields in the reference; the script sends it anyway. If it is ignored, the block in AGENTS.md / GEMINI.md still carries the state.
• The names of the built-in edit tools (we assume write_file, replace and edit) and the path field inside their input (file_path). If they differ, the lock does nothing and never blocks.
• Whether Gemini sends a session_id to the hooks (same consequence as for Codex), and a project-folder variable: none is documented, the scripts use the working directory.

Cursor

Cursor has no hooks: everything goes through the MCP server and a rule that tells the agent what to call.

1. Add the server to .cursor/mcp.json in the project (or ~/.cursor/mcp.json for every project):
   { "mcpServers": { "codelux": { "url": "http://localhost:8766/mcp" } } }
2. Create the rule .cursor/rules/codelux.mdc:
   --- description: Codelux project memory alwaysApply: true --- This project uses Codelux (MCP server "codelux"). - At the start of a task call memory_get with no arguments and continue from it. - Before relying on a name or a path, check it with code_query or code_context. - Write files through code_edit, so the file is locked against other agents and the edit lands on the Timeline with its diff. - When you finish, call memory_set once: summary, status, next, traps, decisions.
3. Restart Cursor, or reload its MCP servers.

Say who you are: one name on every channel

Every agent gives itself a short codename (w375, tree-blocks) and passes it on every channel: MCP argument agent, REST agent= or X-Codelux-Agent, CLI --agent=. Codelux AI joins it to the host's own session (and subagent), so the edits seen by the hooks, the MCP calls and the REST or CLI calls are ONE row on the timeline: the name as the title, the host (Claude Code, Claude Code subagent, Codex, Gemini CLI, Cursor, REST, Other agent) beside it, the session id in the tooltip. A session that has not said its name yet shows as waiting for its name and takes it at its first call that gives it, also for what it did before. With the Claude Code plugin nothing else is needed; other hosts can pass the session too, see REST / cURL.

Check that it works

After a short session, the agent's memories, edits and locks are on the timeline with its name. Read them back over REST:

🖥 IDE Setup (MCP)

Codelux AI speaks native MCP. One config line connects it to any MCP-capable editor or agent. Without the Claude Code plugin there are no hooks: the agent reads its memory when it calls memory_get (or from the AGENTS.md block) and the lock is taken by code_edit instead of around its own editor.

Claude Code (without the plugin)

The plugin is the recommended way. By hand, add to .mcp.json in your project root (or ~/.claude.json for all projects):

Cursor

Add to .cursor/mcp.json in your project (or ~/.cursor/mcp.json globally):

VS Code (Copilot Chat)

Add to .vscode/mcp.json in your workspace:

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

JetBrains (AI Assistant)

Settings → Tools → AI Assistant → Model Context Protocol → Add server → URL http://localhost:8766/mcp.

Zed

Settings → context_servers → add Codelux AI with the same URL.

Any other MCP client

Codelux AI exposes standard MCP at http://localhost:8766/mcp (streamable HTTP; the older SSE transport stays at /sse). If your tool speaks MCP, it works. Every transport lists the 8 core tools; add ?profile=full to the URL to list the rest as well.

🧰 MCP Tools

8 tools, listed by every transport by default. Once connected, your AI picks the right one; with the Claude Code plugin the first read and the file lock happen from hooks, without a call.

Memory

Notes

Check against the code

Writing and agents

A session with the plugin

1. Session starts — the hook puts the newest memory in context: what was done, what is next, the traps
2. You type a prompt — if a codemap, a fact or a decision matches, the hook adds it; otherwise nothing
3. code_query / code_context — check a name or a dependency before touching it
4. Edit with Claude Code's own tools — the hook takes the lock before and releases it after
5. notes_set — a todo for you, a form when it needs an answer, a decision and the why
6. memory_set — the session closes with its memory; the Stop hook reminds the model if it forgot

Every one of these steps is an event on the timeline.

🕒 Timeline

The timeline is the record of everything that happens on a project, emitted by Codelux AI itself: you never write to it, and nothing on it is lost — a delete is an event that keeps the previous content.

What lands on it

Where to read it

• Timeline tab of the dashboard: events in order, filters by type, topic, author, period and file; a click opens the original — the note, the memory, the file diff, the commit.
• For the agent: memory_get with events: true, with the same filters.
• On a team: every event reaches every member's machine, encrypted with the team key, with who did it.

🌐 REST / cURL

Every tool is also a plain HTTP endpoint. Scripts, CI pipelines, custom tooling, legacy editors: anything that can make an HTTP call can use Codelux AI.

Base URL

{project} is the name of an indexed project. List them with /api/projects.

Say who you are. Every call below that reads or writes the project must name the calling agent, the same way on MCP, REST and the CLI: agent=<codename> in the query or in the JSON body, or the header X-Codelux-Agent: <codename> (CLI: --agent=<codename> or the CODELUX_AGENT variable; MCP: the agent argument, filled by the client). Without it the call is refused with 400 agent required; with it, the timeline shows the agent by name. To call an MCP tool by its own name and arguments: POST /api/project/{project}/tool/{name}.

Same agent, same row. To tie a REST call to the agent's own session (the one its hooks report), add session=<host session id> and provider=claude-code|codex|gemini|cursor|other, plus subagent=<id> inside a subagent; or the headers X-Codelux-Session, X-Codelux-Provider, X-Codelux-Subagent (CLI: --session, --provider, --subagent or the variables CODELUX_SESSION, CODELUX_PROVIDER, CODELUX_SUBAGENT). With the Claude Code plugin the session start sets CODELUX_SESSION and CODELUX_PROVIDER in every Bash command, and the hook reads the name in a command that calls Codelux AI: the name alone is enough. Without any session id, the agent is one row per name, shown as Other agent.

Search & read

Analyze

Memory, notes & timeline

Writes & git

Manage

⌨️ CLI Commands

The binary doubles as a CLI — useful for quick checks without leaving the terminal.

Running codelux.exe (Windows) or ./codelux (Linux) with no arguments prints the command list — run codelux start to launch the server. The following sub-commands are available for terminal use:

Read & search

Memory & notes

Writes & index

Example session

📊 Web Dashboard

Codelux AI ships a built-in web dashboard at http://localhost:8766 — manage every project from the browser, even when Codelux AI runs on a remote server.

Tabs

Server / headless install

Run Codelux AI on a server and open the dashboard from any browser: web login, multi-project sidebar, per-project configuration.

Projects and plans

Codelux AI keeps watching and indexing every project you register, on every plan — the plan decides what you can act on, not what is kept up to date. On Free one project is active at a time: the others show an Activate this project action instead of their tabs, and the tools stay disabled until you switch, which you do from the app. On Multi and Team every project is active at once, with no activation limit.

👥 Teams

The Team plan shares one project between the people you invite. Memories, notes, the timeline, chat and edit history travel between machines as encrypted events; the file semaphore and who is online are coordinated live. Code and index never leave anyone's machine, and the key that protects the shared data never reaches us.

Where everything lives

1. Buy the seats

The Team plan is a yearly subscription of the team owner, priced per seat with a minimum seat count — both are on the pricing page. Seats count distinct people across every team you own, the owner included: the same person in two of your teams uses one seat. Members join with their own account and need no plan of their own.

2. Create the team on the site

In the Console, open Teams → New Team: give it a name, pick one project from your account's project list, add the members' email addresses and choose how the team shares files (Git clones or Shared folder, see step 7). One team = one project; create another team for another project. Each member receives an invitation by email — without an account yet, the link takes them to registration first — and accepts it from their own Console. Nothing about the team's contents is ever visible on the site.

3. The owner's app makes the keys

The owner's Codelux AI generates, once, a master key (256 random bits) in Settings → Keys and keeps it sealed on that computer. The key of each team is derived from it, version by version; our server keeps only a public check value per team and version, which reveals nothing about the key. The owner can show and copy the master key behind a confirmation, and export it to a file (protected with a passphrase, recommended) to set up another computer. No button on the site or in the app ever sends a key to us.

4. Hand the key to the members

• Copy team key — in Settings → Keys the owner copies the key of one team (it starts with cdx-t-) and sends it to that team's members over a channel they trust (in person, a message, a password manager). It opens only that team; the master key is never given to members.
• Paste the team key — the member pastes it in the banner of the team's project; spaces, dashes and case are ignored, and the app checks it against the server's check value before keeping it (a wrong key is refused at once).

Every member keeps every key version they receive, so events written before a rotation stay readable on their machine.

5. Point each machine at the project folder

Shared projects appear in the sidebar under Shared with you, grouped by team. On the owner's machine the folder is taken from the project list; on every other machine the member chooses Set folder on this machine… and gives the path of their clone (Git clones) or of the shared folder (Shared folder). The path is recorded per machine, so the same project can live at different paths on different computers. A shared project is ready once the machine has both the folder and the key.

6. The Team tab

When the selected project belongs to a team, the dashboard gains a Team tab: the chat with its channels — the team channel, direct messages between two members and groups created by the owner or an admin — the member list with who is online, and the file locks showing who is editing what. Notes, journal, facts and CodeMap carry the author of each entry and a filter (All · Me · a member). Without the key the tab offers only Paste the team key.

7. Git clones or Shared folder

In both modes the rule is the same: writes to the shared project go through only while the realtime service that holds the locks is reachable. When it is not, edits to the shared project through the Claude Code hook on Edit and Write are refused with a clear message, never applied blindly.

8. Members on the Free plan

A member covered by the owner's seats is entitled to the Team build: My account › Downloads in the Console shows it as Team build (covered by <team>). They download it, sign in with their own account and work on the shared project with locks, presence and chat; their own projects follow their own plan (on Free, one active project per machine). The public Free build has no realtime client: with the folder and the key it can read the shared knowledge, but every write on the shared project answers Team build required.

9. Removing a member, rotating the key

Members are removed from the site; removal cuts their access to new events at once, but whatever already reached their machine stays there. When that matters, the owner presses Turn key in Settings → Keys: the version number goes up and new data is sealed with the new key; the members who stay keep reading the old data and get the new key from the owner (Paste the team key). Turn it too whenever you suspect the key has leaked.

10. Machines, offline, and when the plan lapses

• One Codelux AI per machine. Signing in with the same account on another machine takes over; the previous one is signed out (the last login wins). This holds for every member.
• Offline. The app checks in with the licence server every minute; after three failed checks it is offline and, until the next successful one, writes to shared projects are refused — the same fail-closed rule as a realtime outage. There is no offline grace period on any plan.
• Plan lapsed or seats exceeded. The team goes dormant: its shared project is no longer authorised for the members, who see Plan lapsed. Nothing is deleted and no key is touched — the keys stay on every machine, the events stay on the server, and everything resumes at the renewal. Meanwhile the owner can still remove members or delete the team.
• Deleting the team. Removes every encrypted event and all team metadata from our servers. What each member already has on their machine stays there and remains theirs.

11. Roles: Admin, Manager, Member

Admin — buys the seats and administers the organization from the Console: creates teams, invites people, assigns each person as Manager or Member of each team, names the organization Admins, sets up SSO and SCIM. Manager — coordinates a team in the app: Tasks (key, title, assignee, start and due date, status, checklist, planned and actual %) as a list, a board and a Gantt, shared end-to-end encrypted like notes; Generate reports builds one standup per member per day from the timeline only — memories, checkpoints, closed todos, file edits, locks, tasks moved — never from the chat, and the manager confirms the actual %; People of his team with agents seen, last activity and a per-member download (no chat) that is itself recorded on the timeline; usage and costs per member. Member — works with agents and sees the team plan, their own plan, usage, the timeline and the chat. A person can hold several roles. In the app the project list is grouped: personal projects, then the teams you are a member of, then the teams you manage. Hosted by us, a team has Codelux AI planning, chat, standups, timeline, memory, semaphore, usage, costs and audit — and no connector.

12. Sign-in, SSO, SCIM and organisation admins

Every account can sign in with email and password plus an email code, or with Google, GitHub or Slack. The owner of a Team plan can connect the company's identity provider over OIDC or SAML 2.0 for verified domains, require SSO for them (the owner keeps every sign-in method as the way back in), and issue a SCIM 2.0 token: a person deactivated in the provider is removed from all the owner's teams, signed out everywhere, and a key rotation is requested. In Admins the owner names organisation admins, who administer all of the owner's teams but cannot change billing or delete the organisation. The documents for your IT review are on the Security page.

13. Integrations: the company hub

Integrations are not part of our hosted service. With the company hub, codelux-hub — a program your company runs, included in Team and Enterprise — a team also gets Jira, Linear, Asana, Azure Boards, GitHub, GitLab and Slack notifications, executed by the hub and always on. The Admin connects each provider once for the organization; the Manager of a team picks, among them, the team's Jira project, repository or Slack channel, without handling any token. An organization is either entirely on our hosted service or entirely on its hub, and a migration package moves a team from one to the other. Register and download the hub from My account › Downloads › Hub in the Console. We never see your code, memories, timeline, nor your tokens.

What we do not do

• We never receive, store or forward the team key. There is no escrow and no recovery: if every member loses it, the encrypted events are unreadable — for you and for us.
• We cannot read memories, notes, the timeline, CodeMaps, edit history or chat. We do not know what kind of event it is or which file it refers to.
• We do not upload code or index files, on any plan.
• We do not make direct messages private towards the team — see step 6.
• The planning and chat service is hosted by us and has no connector. A company that wants integrations runs its own hub, codelux-hub (included with Team): it executes Jira, Linear, Asana, Azure Boards, GitHub, GitLab and Slack notifications with tokens that stay on your side. The DPA template, the security questionnaire and the deployment guide are on the Security page; a signed DPA is available on request.