claude-cluster docs1.10.1
ReferenceRéférence

Settings referenceRéférence des réglages

Every option of the settings page, with its key, kind, choices and help - generated from the code.Chaque option de la page de réglages, avec sa clé, son type, ses choix et son aide - générée depuis le code.

Every option of the settings page (F9, the palette Settings, the web page ⚙) with its key in config.toml, generated from the settings tables of the sources. The default values and the comments of the file are in the configuration reference. Settings applied only at the next start are marked ↻.

Chaque option de la page de réglages (F9, la palette Settings, le ⚙ de la page web) avec sa clé dans config.toml, générée depuis les tables de réglages du code. Les valeurs par défaut et les commentaires du fichier sont dans la référence de configuration. Les réglages pris en compte seulement au prochain démarrage sont marqués ↻.

Les libellés et aides viennent du code, en anglais.

1. InterfaceInterface

SettingTypeWhat it does
Front-end
ui.frontend ↻
choice: auto | tty | guiauto: terminal when in a terminal, else a window (--tty / --gui win); also what the wake phrase opens when claude-cluster is closed (auto: a window, a terminal on its failure)
Terminal emulator
ui.terminal
textthe terminal opened when one is needed (the wake phrase with Front-end tty, or a window that failed), with its option to run a command (kitty, alacritty -e...); empty: the first installed
Matching of the lists
ui.matching
choice: c2dmp | rawthe completions (/command, @file, !command, :command, models...), the palette and the search of the settings: c2dmp (c2dmp-hsm of libutils: typos and misplaced letters found, the closest first) or raw (what starts with the text typed, then what contains it)
!command given to the agent
ui.shell_context
choice: ask | always | nevera !command typed in the prompt: its command and its output given to the agent of the session with your next prompt (like Claude Code); ask: chosen after it ran (this time, always, not this time, never: always / never are written here, ask again from here)
Several terminals / windows at once
ui.shared_core ↻
boolclaude-cluster opened again: attached to the one running, every terminal and window in sync (the core of the sessions in a process of its own, until the last one closes); off: opened again is refused
Restart a crashed core
ui.restart_core ↻
boolthe core runs under a small watcher: crashed (a fault, an abort), it is started again with its sessions restored - never after a normal end, never over another core, at most 5 times in 10 minutes; off: no watcher (at the next start of the core)
Quit with sessions running
ui.quit_background
choice: ask | always | neverthe last terminal / window closed while a session works (or has prompts queued): • ask: a popup - keep them running in background (the core goes on without interface, its web access closed, stopped by itself once every session is idle; claude-cluster opened again meanwhile shows them) / stop everything / back • always: kept without asking • never: stopped (the turns interrupted, the sessions kept for the next start)
Window mode
ui.gui_mode
choice: gui | ttygui: the window and its own interface; tty: the window shows the terminal interface (a real terminal inside it, every key of it; -g --tty-mode for one run)
Interface
ui.mode
choice: classic | simpleclassic: every view and every setting; simple: what needs you first, a card per session in plain words, the same prompt, the useful settings only (--simple / --ipad-kid for one run)
Language of the simple mode
ui.language
choice: en | frthe words of the simple interface (English, French)
Layout
ui.layout
choice: list | grid | graph | hub | tree | tabsthe view at the start, the same five everywhere (F2 goes through them): list (the sessions and the active one), grid (every session in a cell), graph (the global session in the middle, its categories / tags, then their sessions), hub (every session around the global one), tree (the sessions by project folder); tabs: the window only
Style
ui.style
choicecolors of the interface (own ones: [styles.<name>] in the file)
Prompts coloured by origin
ui.prompt_origin
boolthe prompts of a transcript by where they come from: you, mcp (the global session, replies, answers), task (tasks and schedules); with a label in the header. Off: all prompts as before
Color of your prompts
ui.prompt_color_user
text#rrggbb, empty: the accent of the style (as before)
Color of the mcp prompts
ui.prompt_color_mcp
text#rrggbb, empty: violet (#8a3fb5 light, #bb8cf2 dark)
Color of the task prompts
ui.prompt_color_task
text#rrggbb, empty: magenta (#b3267a light, #f08ccb dark); tasks and schedules
Panels of a new session
ui.panels
listskills, tokens, context, cost, git, diff, tools, files
Previous sessions at start
ui.restore ↻
choice: ask | always | neverask at every start (default, like Firefox: r restore, n new, q quit), always restore, never (to the trash)
Vim mode of the prompt
ui.vim
boolEsc: Normal mode (hjkl w b e 0 $ x dd dw cw yy p u v V...), i / a / o: Insert
Group the session list by category
ui.group_by_category
boolthe sessions under the category the global session or you gave them (terminal, window, web page; the palette: Group by category)
Paste collapsed above (lines)
ui.paste_lines
inta longer paste is one [Pasted text #N +L lines] in the prompt (0: never)
Stash: prompts kept
ui.stash_max
intthe prompts put aside (Ctrl+S, the list: Ctrl+L); the prompts copied by themselves (a prompt replaced by another one) never are refused
Stash: when it is full
ui.stash_full
choice: refuse | drop_oldestrefuse: the prompt stays in the editor, nothing is lost; drop_oldest: the oldest stashed prompt makes room (with a notice)
Stash: the prompts a rewind drops
ui.stash_rewound
boolEsc (the chooser of the points of the conversation): the prompts it removes are put in the stash too
Paste collapsed above (characters)
ui.paste_chars
inta longer paste is one [Pasted text #N] in the prompt (0: never)
Editor of the prompt (Ctrl+E)
ui.editor
textempty: nvim, vim, vi, $VISUAL, $EDITOR, emacs -nw, nano (the first installed)
Image viewer (right click on a chip)
ui.image_viewer
textempty: xdg-open (the viewer of the desktop)
Image preview (terminal)
ui.image_preview
choice: blocks | chafablocks: the pixels as half blocks; chafa: its symbols
Answers typed as they come
ui.typewriter
boolthe text appears a few characters at a time, also when the agent sends it at once
Typing speed (characters / s)
ui.typewriter_speed
intfaster by itself when a long text is behind (never more than ~1.5 s late)
Desktop notifications
ui.notify
boolall of them (off: none); their face, their buttons (Allow / Deny, the options of a question, Open), one per session
Start menu
ui.start_menu
boolat each start of the terminal: open the claude-cluster that runs, an independent instance (its own sessions and global session), restore the previous run, start new, or quit (off: the previous run is asked only when there is one)
When
ui.notify_when
choice: unfocused | alwaysunfocused: only when claude-cluster is not in front (its terminal / window not focused: its own popups are in front of you); always: also when it is
The global session answers
ui.notify_global
bool^_^ the end of its answers (their first words)
A session finishes
ui.notify_done
bool>‿< the end of a turn of a sub-session (its tokens)
A permission waits
ui.notify_permission
bool•_• a tool waits for your yes (Allow / Deny from the notification); o_o: the safety check
A question of an agent
ui.notify_question
bool•_• its options as buttons when there is one question
An error, a crash
ui.notify_error
boolo_o a turn failed, a session stopped
A limit close or reached
ui.notify_limits
boolo_o 80 % / 95 % of the 5 h / 7 d windows; -_- reached (until its reset)
Web devices
ui.notify_web
bool•_• a device asks to connect (Allow / Allow and trust / Deny), ^_^ a device connected
The task queue done
ui.notify_tasks
bool>‿< one summary when every task is over
Each task done
ui.notify_task_each
boola notification at the end of each task (task_add notify: true asks it for one)
Reminders
ui.notify_reminders
bool•_• schedule add --notify, at its time
Something slow is ready
ui.notify_ready
bool^_^ claude-cluster started (its global session), the speech model loaded, the map of this computer written: come back when it is there
Android app
ui.notify_app
boolthe same notifications published to the Android app (the kinds above apply; shown when the app is not in front, each phone chooses its own kinds in its This device page; off: none sent)
With a sound
ui.notify_sound
boola short sound of the desktop theme, one per kind (done, question, error, web)
Map: sync proposed after (days)
ui.machine_days
intthe map of this computer older: a sync proposed at start (0: never)
RéglageTypeRôle
Front-end
ui.frontend ↻
choice: auto | tty | guiauto: terminal when in a terminal, else a window (--tty / --gui win); also what the wake phrase opens when claude-cluster is closed (auto: a window, a terminal on its failure)
Terminal emulator
ui.terminal
textthe terminal opened when one is needed (the wake phrase with Front-end tty, or a window that failed), with its option to run a command (kitty, alacritty -e...); empty: the first installed
Matching of the lists
ui.matching
choice: c2dmp | rawthe completions (/command, @file, !command, :command, models...), the palette and the search of the settings: c2dmp (c2dmp-hsm of libutils: typos and misplaced letters found, the closest first) or raw (what starts with the text typed, then what contains it)
!command given to the agent
ui.shell_context
choice: ask | always | nevera !command typed in the prompt: its command and its output given to the agent of the session with your next prompt (like Claude Code); ask: chosen after it ran (this time, always, not this time, never: always / never are written here, ask again from here)
Several terminals / windows at once
ui.shared_core ↻
boolclaude-cluster opened again: attached to the one running, every terminal and window in sync (the core of the sessions in a process of its own, until the last one closes); off: opened again is refused
Restart a crashed core
ui.restart_core ↻
boolthe core runs under a small watcher: crashed (a fault, an abort), it is started again with its sessions restored - never after a normal end, never over another core, at most 5 times in 10 minutes; off: no watcher (at the next start of the core)
Quit with sessions running
ui.quit_background
choice: ask | always | neverthe last terminal / window closed while a session works (or has prompts queued): • ask: a popup - keep them running in background (the core goes on without interface, its web access closed, stopped by itself once every session is idle; claude-cluster opened again meanwhile shows them) / stop everything / back • always: kept without asking • never: stopped (the turns interrupted, the sessions kept for the next start)
Window mode
ui.gui_mode
choice: gui | ttygui: the window and its own interface; tty: the window shows the terminal interface (a real terminal inside it, every key of it; -g --tty-mode for one run)
Interface
ui.mode
choice: classic | simpleclassic: every view and every setting; simple: what needs you first, a card per session in plain words, the same prompt, the useful settings only (--simple / --ipad-kid for one run)
Language of the simple mode
ui.language
choice: en | frthe words of the simple interface (English, French)
Layout
ui.layout
choice: list | grid | graph | hub | tree | tabsthe view at the start, the same five everywhere (F2 goes through them): list (the sessions and the active one), grid (every session in a cell), graph (the global session in the middle, its categories / tags, then their sessions), hub (every session around the global one), tree (the sessions by project folder); tabs: the window only
Style
ui.style
choicecolors of the interface (own ones: [styles.<name>] in the file)
Prompts coloured by origin
ui.prompt_origin
boolthe prompts of a transcript by where they come from: you, mcp (the global session, replies, answers), task (tasks and schedules); with a label in the header. Off: all prompts as before
Color of your prompts
ui.prompt_color_user
text#rrggbb, empty: the accent of the style (as before)
Color of the mcp prompts
ui.prompt_color_mcp
text#rrggbb, empty: violet (#8a3fb5 light, #bb8cf2 dark)
Color of the task prompts
ui.prompt_color_task
text#rrggbb, empty: magenta (#b3267a light, #f08ccb dark); tasks and schedules
Panels of a new session
ui.panels
listskills, tokens, context, cost, git, diff, tools, files
Previous sessions at start
ui.restore ↻
choice: ask | always | neverask at every start (default, like Firefox: r restore, n new, q quit), always restore, never (to the trash)
Vim mode of the prompt
ui.vim
boolEsc: Normal mode (hjkl w b e 0 $ x dd dw cw yy p u v V...), i / a / o: Insert
Group the session list by category
ui.group_by_category
boolthe sessions under the category the global session or you gave them (terminal, window, web page; the palette: Group by category)
Paste collapsed above (lines)
ui.paste_lines
inta longer paste is one [Pasted text #N +L lines] in the prompt (0: never)
Stash: prompts kept
ui.stash_max
intthe prompts put aside (Ctrl+S, the list: Ctrl+L); the prompts copied by themselves (a prompt replaced by another one) never are refused
Stash: when it is full
ui.stash_full
choice: refuse | drop_oldestrefuse: the prompt stays in the editor, nothing is lost; drop_oldest: the oldest stashed prompt makes room (with a notice)
Stash: the prompts a rewind drops
ui.stash_rewound
boolEsc (the chooser of the points of the conversation): the prompts it removes are put in the stash too
Paste collapsed above (characters)
ui.paste_chars
inta longer paste is one [Pasted text #N] in the prompt (0: never)
Editor of the prompt (Ctrl+E)
ui.editor
textempty: nvim, vim, vi, $VISUAL, $EDITOR, emacs -nw, nano (the first installed)
Image viewer (right click on a chip)
ui.image_viewer
textempty: xdg-open (the viewer of the desktop)
Image preview (terminal)
ui.image_preview
choice: blocks | chafablocks: the pixels as half blocks; chafa: its symbols
Answers typed as they come
ui.typewriter
boolthe text appears a few characters at a time, also when the agent sends it at once
Typing speed (characters / s)
ui.typewriter_speed
intfaster by itself when a long text is behind (never more than ~1.5 s late)
Desktop notifications
ui.notify
boolall of them (off: none); their face, their buttons (Allow / Deny, the options of a question, Open), one per session
Start menu
ui.start_menu
boolat each start of the terminal: open the claude-cluster that runs, an independent instance (its own sessions and global session), restore the previous run, start new, or quit (off: the previous run is asked only when there is one)
When
ui.notify_when
choice: unfocused | alwaysunfocused: only when claude-cluster is not in front (its terminal / window not focused: its own popups are in front of you); always: also when it is
The global session answers
ui.notify_global
bool^_^ the end of its answers (their first words)
A session finishes
ui.notify_done
bool>‿< the end of a turn of a sub-session (its tokens)
A permission waits
ui.notify_permission
bool•_• a tool waits for your yes (Allow / Deny from the notification); o_o: the safety check
A question of an agent
ui.notify_question
bool•_• its options as buttons when there is one question
An error, a crash
ui.notify_error
boolo_o a turn failed, a session stopped
A limit close or reached
ui.notify_limits
boolo_o 80 % / 95 % of the 5 h / 7 d windows; -_- reached (until its reset)
Web devices
ui.notify_web
bool•_• a device asks to connect (Allow / Allow and trust / Deny), ^_^ a device connected
The task queue done
ui.notify_tasks
bool>‿< one summary when every task is over
Each task done
ui.notify_task_each
boola notification at the end of each task (task_add notify: true asks it for one)
Reminders
ui.notify_reminders
bool•_• schedule add --notify, at its time
Something slow is ready
ui.notify_ready
bool^_^ claude-cluster started (its global session), the speech model loaded, the map of this computer written: come back when it is there
Android app
ui.notify_app
boolthe same notifications published to the Android app (the kinds above apply; shown when the app is not in front, each phone chooses its own kinds in its This device page; off: none sent)
With a sound
ui.notify_sound
boola short sound of the desktop theme, one per kind (done, question, error, web)
Map: sync proposed after (days)
ui.machine_days
intthe map of this computer older: a sync proposed at start (0: never)

2. AgentAgent

SettingTypeWhat it does
Provider of every session
agent.provider ↻
textthe global session, every sub-session (existing, new, imported conversations): <provider>[/<model>] - claude, ollama/<model>, openai/<model>, opencode/<p>/<m>, codex; the global session needs a claude-driver one (claude, ollama, anthropic-api...)
Permission mode
agent.permission_mode
choicemode of the new sessions (empty: the default of the agent)
Thinking effort
agent.effort
choiceof the new sessions (empty: the default of the agent; per session: /effort, the palette)
bypassPermissions possible
agent.allow_bypass ↻
boolclaude launched with --allow-dangerously-skip-permissions (needed to switch to bypass)
Orchestration mode
agent.orchestration
choice: compact | hybrid | ultrahow readily the global session splits work into sub-sessions (told to it in its system prompt, taken at its next start): compact - the fewest tokens, medium tasks go in ONE session (one per project), it asks you before splitting; hybrid - several sub-sessions when it pays, sub-globals rarely; ultra - a sub-session (and sub-globals) for each different task
Workflows of the model
agent.workflow ↻
boolthe multi-agent workflows of the model itself, when it has them (Claude Code: its Workflow tool, ultracode: dozens of agents, a lot of tokens): on - allowed and asked, it uses them on a big task; off - never (the tool taken away from it). For the sessions started from now
Work method
agent.work_method
choice: free | list-review | one-task | plan-first | customhow the work is organised: injected, short, in the system prompt of the sub-sessions and of the global session, which splits the requests accordingly; taken by each session at its next start
Work method (free text)
agent.work_method_text
textyour own words, added to the preset (alone with custom): short, 400 characters at most
Detect the work method
agent.work_method_detect
boolthe global session may PROPOSE a method from how you phrase your requests (a small sample of your prompts, no model): a popup you answer Allow / Deny - never applied alone
Detection: every N sessions
agent.work_method_every
intsessions started by the global session between two checks (0: only when asked)
Sub-sessions: see their tasks
agent.sub_read
boola sub-session lists its own tasks and schedules (MCP task_list, schedule_list: the ones it made; never the others). Off: it has no such tool
Sub-sessions: queue tasks
agent.sub_tasks
boola sub-session queues tasks for itself or another session (MCP task_add, task_cancel, task_act on its own tasks)
Sub-sessions: create schedules
agent.sub_schedules
boola sub-session schedules prompts, notifications or tasks (MCP schedule_add, schedule_edit): off by default - a repeated schedule runs by itself, long after
Sub-sessions: tasks that start sessions
agent.sub_spawn
boola task or a schedule of a sub-session may start sessions of its own (each costs tokens): off by default
Global session can pin
agent.global_pin
boolthe global session may pin a message or a display block at the bottom of the view of any session (MCP session_pin, session_unpin); you can always pin by hand (right click, Ctrl+K: Pin / Unpin)
Global session can edit the taxonomy
agent.taxonomy_edit
boolthe global session may set the parent of a category / tag, rename, delete and merge them (MCP taxonomy), which moves the sessions in the graph and the grouped list; you can always edit it by hand (graph, palette, claude-cluster taxonomy)
Sub-sessions can pin
agent.sub_pin
boola sub-session may pin an item on its own view (a task list, a form you keep seeing); never on another session
Sub-sessions: sessions started at most
agent.sub_spawn_cap
intthe sessions of its tasks / schedules a sub-session may have waiting or open at once (past it a new one is refused); the global session has no cap
Extra arguments (claude)
agent.extra_args ↻
listadded to every claude session, comma separated
RéglageTypeRôle
Provider of every session
agent.provider ↻
textthe global session, every sub-session (existing, new, imported conversations): <provider>[/<model>] - claude, ollama/<model>, openai/<model>, opencode/<p>/<m>, codex; the global session needs a claude-driver one (claude, ollama, anthropic-api...)
Permission mode
agent.permission_mode
choicemode of the new sessions (empty: the default of the agent)
Thinking effort
agent.effort
choiceof the new sessions (empty: the default of the agent; per session: /effort, the palette)
bypassPermissions possible
agent.allow_bypass ↻
boolclaude launched with --allow-dangerously-skip-permissions (needed to switch to bypass)
Orchestration mode
agent.orchestration
choice: compact | hybrid | ultrahow readily the global session splits work into sub-sessions (told to it in its system prompt, taken at its next start): compact - the fewest tokens, medium tasks go in ONE session (one per project), it asks you before splitting; hybrid - several sub-sessions when it pays, sub-globals rarely; ultra - a sub-session (and sub-globals) for each different task
Workflows of the model
agent.workflow ↻
boolthe multi-agent workflows of the model itself, when it has them (Claude Code: its Workflow tool, ultracode: dozens of agents, a lot of tokens): on - allowed and asked, it uses them on a big task; off - never (the tool taken away from it). For the sessions started from now
Work method
agent.work_method
choice: free | list-review | one-task | plan-first | customhow the work is organised: injected, short, in the system prompt of the sub-sessions and of the global session, which splits the requests accordingly; taken by each session at its next start
Work method (free text)
agent.work_method_text
textyour own words, added to the preset (alone with custom): short, 400 characters at most
Detect the work method
agent.work_method_detect
boolthe global session may PROPOSE a method from how you phrase your requests (a small sample of your prompts, no model): a popup you answer Allow / Deny - never applied alone
Detection: every N sessions
agent.work_method_every
intsessions started by the global session between two checks (0: only when asked)
Sub-sessions: see their tasks
agent.sub_read
boola sub-session lists its own tasks and schedules (MCP task_list, schedule_list: the ones it made; never the others). Off: it has no such tool
Sub-sessions: queue tasks
agent.sub_tasks
boola sub-session queues tasks for itself or another session (MCP task_add, task_cancel, task_act on its own tasks)
Sub-sessions: create schedules
agent.sub_schedules
boola sub-session schedules prompts, notifications or tasks (MCP schedule_add, schedule_edit): off by default - a repeated schedule runs by itself, long after
Sub-sessions: tasks that start sessions
agent.sub_spawn
boola task or a schedule of a sub-session may start sessions of its own (each costs tokens): off by default
Global session can pin
agent.global_pin
boolthe global session may pin a message or a display block at the bottom of the view of any session (MCP session_pin, session_unpin); you can always pin by hand (right click, Ctrl+K: Pin / Unpin)
Global session can edit the taxonomy
agent.taxonomy_edit
boolthe global session may set the parent of a category / tag, rename, delete and merge them (MCP taxonomy), which moves the sessions in the graph and the grouped list; you can always edit it by hand (graph, palette, claude-cluster taxonomy)
Sub-sessions can pin
agent.sub_pin
boola sub-session may pin an item on its own view (a task list, a form you keep seeing); never on another session
Sub-sessions: sessions started at most
agent.sub_spawn_cap
intthe sessions of its tasks / schedules a sub-session may have waiting or open at once (past it a new one is refused); the global session has no cap
Extra arguments (claude)
agent.extra_args ↻
listadded to every claude session, comma separated

3. ServiceService

SettingTypeWhat it does
Keep the computer awake
service.keep_awake
choice: off | working | alwaysthe computer does not go to sleep by itself (idle suspend; a locked screen never stops claude-cluster, only a suspend does): off - never; working - while a session works on a turn; always - while claude-cluster runs. The lid and the suspend menu still work (systemd-inhibit, idle only)
RéglageTypeRôle
Keep the computer awake
service.keep_awake
choice: off | working | alwaysthe computer does not go to sleep by itself (idle suspend; a locked screen never stops claude-cluster, only a suspend does): off - never; working - while a session works on a turn; always - while claude-cluster runs. The lid and the suspend menu still work (systemd-inhibit, idle only)

4. Global sessionSession globale

SettingTypeWhat it does
Enabled
global.enabled ↻
boolthe session that manages the others (MCP)
Model
global.model ↻
textempty: the default model of the provider ([agent] provider)
Permission mode
global.permission_mode ↻
choiceapplied at every start (bypassPermissions: it never asks)
Thinking effort
global.effort ↻
choiceapplied at every start (empty: its own, /effort, else the one of [agent])
Context at most
global.context ↻
choiceits conversation compacted once it reaches this size (Claude Code: CLAUDE_CODE_AUTO_COMPACT_WINDOW): a smaller context costs less at every turn and a wake-up after its cache expired reloads less (not 1M tokens); auto: the window of the model. 100k to 1M
Folder
global.cwd ↻
textworking folder of the global session
System prompt file
global.prompt ↻
textits own system prompt, added to CLAUDE.md
Remote Control name
global.remote_name
textname of the Remote Control session
System prompt (edit)
global.edit_prompt
actionopens it in the editor ([ui] editor, else nvim, vim, vi, $VISUAL, $EDITOR...); saved: the global session restarted on the same conversation
Map of this computer (sync)
global.machine_sync
actionscans again what the global session knows of this computer (asks first): OS, user, shell aliases, tools, git repositories
RéglageTypeRôle
Enabled
global.enabled ↻
boolthe session that manages the others (MCP)
Model
global.model ↻
textempty: the default model of the provider ([agent] provider)
Permission mode
global.permission_mode ↻
choiceapplied at every start (bypassPermissions: it never asks)
Thinking effort
global.effort ↻
choiceapplied at every start (empty: its own, /effort, else the one of [agent])
Context at most
global.context ↻
choiceits conversation compacted once it reaches this size (Claude Code: CLAUDE_CODE_AUTO_COMPACT_WINDOW): a smaller context costs less at every turn and a wake-up after its cache expired reloads less (not 1M tokens); auto: the window of the model. 100k to 1M
Folder
global.cwd ↻
textworking folder of the global session
System prompt file
global.prompt ↻
textits own system prompt, added to CLAUDE.md
Remote Control name
global.remote_name
textname of the Remote Control session
System prompt (edit)
global.edit_prompt
actionopens it in the editor ([ui] editor, else nvim, vim, vi, $VISUAL, $EDITOR...); saved: the global session restarted on the same conversation
Map of this computer (sync)
global.machine_sync
actionscans again what the global session knows of this computer (asks first): OS, user, shell aliases, tools, git repositories

5. SessionsSessions

SettingTypeWhat it does
Short descriptions
sessions.describe
choice: model | prompt | offa few words under the name of each session (the trash too), to find it again: model: the title Claude Code made, else written by a model (Model of the descriptions; its own process, nothing kept) after its 1st, 3rd, 9th... turn; prompt: its first prompt; off: none written (the ones given kept)
Model of the descriptions
sessions.describe_model
text<provider>/<model> writing them, any provider (claude, codex / OpenAI, opencode, qwen, a local one: ollama/llama3.2...); empty: the provider of each session (haiku for Anthropic)
Trash kept (days)
sessions.trash_days
inta closed session stays restorable this long
Parallel sessions
sessions.max_parallel
intsub-sessions working at the same time: past it, the tasks (task_add, the groups of the global session) wait in the task queue and are sent as soon as a place is free
Queued prompts
sessions.queue_given
choice: end | stepa prompt typed while the turn runs (Claude Code sessions): • end (default): held here until the end of the turn - editable, cancelled (Esc, ↑) or sent now (F8: the turn interrupted) until then • step: given to claude after 1.5 s (Esc edits it before), taken at its next step - between two tool calls - like the queue of Claude Code; given, it can no longer be taken back
Prompt history (prompts)
sessions.history_limit
intthe prompts kept for ↑ / Ctrl+R (history.jsonl): the oldest dropped beyond it; 0: all
Transcript size (MB)
sessions.transcript_limit_mb
inteach conversation kept here (logs/<session>.jsonl, the pictures and display blocks in it): its oldest entries dropped beyond this size (the conversation of the agent itself untouched); 0: no limit
Transcript in memory (MB)
sessions.memory_mb
inteach conversation shown: its newest entries kept in memory within this size (1 to 1024); scrolled to its top, the older ones are read again from its log, up to its very start
Transcripts in memory, all (MB)
sessions.memory_total_mb
intevery conversation in memory together: past this size, the oldest entries of each are dropped from memory (still in their log, read again on demand)
Transcript in memory (entries)
sessions.memory_entries
intalso at most this number of entries in memory per conversation; 0: off (the size only, the default)
Context at most
sessions.context ↻
choicethe conversation of every other session compacted once it reaches this size, like [global] context (the global session may give a sub-session its own when it starts it: smaller for a small task); auto: the window of the model. 100k to 1M
Keep warm (auto wake-up)
sessions.keep_warm
choice: off | chosen | all | backgroundan idle session woken up a little before its prompt cache expires, so its context is never unloaded (the next prompt fast and cheap): a tiny turn (the agent answers ok) costing a cache read. • off: never (the default) • chosen: the sessions marked (/keepwarm, the palette: Keep this session warm) • all: every session • background: only a session waiting on its background (shells / agents running: a long compilation), so its context is not unloaded then loaded again when they end The sessions kept warm show ♨
Keep warm: cache life (min)
sessions.keep_warm_ttl
inthow long the prompt cache of the agent lives: 5 (the default of Claude Code), 60 with a 1 h cache
Keep warm: margin (s)
sessions.keep_warm_margin
intthe wake-up this long before the cache expires (16 to 600 s: checked every 10 s; 45: room for a slow start)
Keep warm: for (hours)
sessions.keep_warm_hours
intkept warm so long after its last real use (a prompt, a take-back, /keepwarm), then left to cool, its ♨ gone (0: never stops)
Task queue
sessions.task_queue
inttasks waiting for a free place, at most (a new one past it is refused)
Task result size
sessions.task_result_chars
intthe answer kept in a task (its result, chained into the prompt of the next one with {{tN.result}}): its first characters, at most
Budget per session (USD)
sessions.budget_usd
float0: none; reached: the session refuses new prompts
Questions on the global session
sessions.questions_to_global
boola question of the agent of a sub-session (AskUserQuestion) shown on the global session, its own one greyed while it waits; answered with the keys, the mouse or the voice (a number or an option, valide / suivant, retour, autre <answer>, annule); off: on its own session only
Global session answers questions
sessions.global_answers
boolthe global session is told the questions of the sub-sessions and may choose their answer (MCP session_allow answers) when it knows what you want; you can answer first
Bypass / auto: global decides
sessions.bypass_to_global
boola sub-session that never asks you (bypassPermissions, auto, dontAsk) still asks for some commands (the safety check of Claude Code: a removal it cannot resolve...): the global session decides them (it asks you when unsure); off: you answer them. In the other modes such a command is asked to you (auto mode: after the check stopped it)
Global session can fork
sessions.global_fork
boolthe global session may copy a sub-session of Claude Code (MCP session_fork: its conversation so far, each one goes on apart) to give a new one its context; you can always (palette, fork)
Global session can edit
sessions.global_edit
boolthe global session may rewrite the conversation of a sub-session of Claude Code (MCP session_edit: texts replaced, messages deleted, its end cut; a new conversation, the old one kept)
Archive one-shot sessions
sessions.archive_one_shot
boola session the global session started for ONE task (session_spawn one_shot) is closed to the trash (restorable) once its answer is relayed; kept when you typed in it, look at it or it waits for you. Off: the flag is ignored
Global session can rewrite its own system prompt
sessions.rewrite_global_prompt
boolthe global session may rewrite its own system prompt (MCP config_write global_prompt): what it obeys at every start, it is started again on it. Off: it asks you (Ctrl+K: edit the system prompt)
Global session can rewrite the system prompt of the sub-sessions
sessions.rewrite_sessions_prompt
boolthe global session may rewrite the system prompt of the sub-sessions (MCP config_write sessions_prompt): each one takes it at its next start. Off: it asks you (Ctrl+K: edit the system prompt)
System prompt file
sessions.prompt
textsystem prompt of every sub-session (claude driver), added to CLAUDE.md; empty file: none
System prompt (edit)
sessions.edit_sessions_prompt
actionopens it in the editor ([ui] editor, else nvim, vim, vi, $VISUAL, $EDITOR...); taken by each sub-session at its next start
RéglageTypeRôle
Short descriptions
sessions.describe
choice: model | prompt | offa few words under the name of each session (the trash too), to find it again: model: the title Claude Code made, else written by a model (Model of the descriptions; its own process, nothing kept) after its 1st, 3rd, 9th... turn; prompt: its first prompt; off: none written (the ones given kept)
Model of the descriptions
sessions.describe_model
text<provider>/<model> writing them, any provider (claude, codex / OpenAI, opencode, qwen, a local one: ollama/llama3.2...); empty: the provider of each session (haiku for Anthropic)
Trash kept (days)
sessions.trash_days
inta closed session stays restorable this long
Parallel sessions
sessions.max_parallel
intsub-sessions working at the same time: past it, the tasks (task_add, the groups of the global session) wait in the task queue and are sent as soon as a place is free
Queued prompts
sessions.queue_given
choice: end | stepa prompt typed while the turn runs (Claude Code sessions): • end (default): held here until the end of the turn - editable, cancelled (Esc, ↑) or sent now (F8: the turn interrupted) until then • step: given to claude after 1.5 s (Esc edits it before), taken at its next step - between two tool calls - like the queue of Claude Code; given, it can no longer be taken back
Prompt history (prompts)
sessions.history_limit
intthe prompts kept for ↑ / Ctrl+R (history.jsonl): the oldest dropped beyond it; 0: all
Transcript size (MB)
sessions.transcript_limit_mb
inteach conversation kept here (logs/<session>.jsonl, the pictures and display blocks in it): its oldest entries dropped beyond this size (the conversation of the agent itself untouched); 0: no limit
Transcript in memory (MB)
sessions.memory_mb
inteach conversation shown: its newest entries kept in memory within this size (1 to 1024); scrolled to its top, the older ones are read again from its log, up to its very start
Transcripts in memory, all (MB)
sessions.memory_total_mb
intevery conversation in memory together: past this size, the oldest entries of each are dropped from memory (still in their log, read again on demand)
Transcript in memory (entries)
sessions.memory_entries
intalso at most this number of entries in memory per conversation; 0: off (the size only, the default)
Context at most
sessions.context ↻
choicethe conversation of every other session compacted once it reaches this size, like [global] context (the global session may give a sub-session its own when it starts it: smaller for a small task); auto: the window of the model. 100k to 1M
Keep warm (auto wake-up)
sessions.keep_warm
choice: off | chosen | all | backgroundan idle session woken up a little before its prompt cache expires, so its context is never unloaded (the next prompt fast and cheap): a tiny turn (the agent answers ok) costing a cache read. • off: never (the default) • chosen: the sessions marked (/keepwarm, the palette: Keep this session warm) • all: every session • background: only a session waiting on its background (shells / agents running: a long compilation), so its context is not unloaded then loaded again when they end The sessions kept warm show ♨
Keep warm: cache life (min)
sessions.keep_warm_ttl
inthow long the prompt cache of the agent lives: 5 (the default of Claude Code), 60 with a 1 h cache
Keep warm: margin (s)
sessions.keep_warm_margin
intthe wake-up this long before the cache expires (16 to 600 s: checked every 10 s; 45: room for a slow start)
Keep warm: for (hours)
sessions.keep_warm_hours
intkept warm so long after its last real use (a prompt, a take-back, /keepwarm), then left to cool, its ♨ gone (0: never stops)
Task queue
sessions.task_queue
inttasks waiting for a free place, at most (a new one past it is refused)
Task result size
sessions.task_result_chars
intthe answer kept in a task (its result, chained into the prompt of the next one with {{tN.result}}): its first characters, at most
Budget per session (USD)
sessions.budget_usd
float0: none; reached: the session refuses new prompts
Questions on the global session
sessions.questions_to_global
boola question of the agent of a sub-session (AskUserQuestion) shown on the global session, its own one greyed while it waits; answered with the keys, the mouse or the voice (a number or an option, valide / suivant, retour, autre <answer>, annule); off: on its own session only
Global session answers questions
sessions.global_answers
boolthe global session is told the questions of the sub-sessions and may choose their answer (MCP session_allow answers) when it knows what you want; you can answer first
Bypass / auto: global decides
sessions.bypass_to_global
boola sub-session that never asks you (bypassPermissions, auto, dontAsk) still asks for some commands (the safety check of Claude Code: a removal it cannot resolve...): the global session decides them (it asks you when unsure); off: you answer them. In the other modes such a command is asked to you (auto mode: after the check stopped it)
Global session can fork
sessions.global_fork
boolthe global session may copy a sub-session of Claude Code (MCP session_fork: its conversation so far, each one goes on apart) to give a new one its context; you can always (palette, fork)
Global session can edit
sessions.global_edit
boolthe global session may rewrite the conversation of a sub-session of Claude Code (MCP session_edit: texts replaced, messages deleted, its end cut; a new conversation, the old one kept)
Archive one-shot sessions
sessions.archive_one_shot
boola session the global session started for ONE task (session_spawn one_shot) is closed to the trash (restorable) once its answer is relayed; kept when you typed in it, look at it or it waits for you. Off: the flag is ignored
Global session can rewrite its own system prompt
sessions.rewrite_global_prompt
boolthe global session may rewrite its own system prompt (MCP config_write global_prompt): what it obeys at every start, it is started again on it. Off: it asks you (Ctrl+K: edit the system prompt)
Global session can rewrite the system prompt of the sub-sessions
sessions.rewrite_sessions_prompt
boolthe global session may rewrite the system prompt of the sub-sessions (MCP config_write sessions_prompt): each one takes it at its next start. Off: it asks you (Ctrl+K: edit the system prompt)
System prompt file
sessions.prompt
textsystem prompt of every sub-session (claude driver), added to CLAUDE.md; empty file: none
System prompt (edit)
sessions.edit_sessions_prompt
actionopens it in the editor ([ui] editor, else nvim, vim, vi, $VISUAL, $EDITOR...); taken by each sub-session at its next start

6. VoiceVoix

SettingTypeWhat it does
Enabled
voice.enabled ↻
boolvoice of the global session (voice-listen / voice-say)
Listening
voice.mode ↻
choice: push | auto | wakepush-to-talk key, always, or after the wake phrase
Microphone
voice.source
textPulseAudio / PipeWire source of the wake phrase heard while claude-cluster is closed (Services > Service), empty: the default one
Wake phrase
voice.wake_word
textwake mode, variants separated by commas (ok claude, okay claude)
Armed (seconds)
voice.wake_seconds
intthe phrase alone: the next sentence within this time is the command
Spoken when armed
voice.wake_reply
textex: Oui ? (empty: silent)
Only my voice
voice.only_me ↻
boolvoice-listen --only-me (needs voice-enroll)
Confirmation (seconds)
voice.confirm_seconds
intthe transcription is shown this long before it is sent
Spoken answers
voice.speak
boolshort summary of the answers of the global session
Summary length
voice.summary_chars
intcharacters of the spoken summary
Speech engine
voice.say_engine
choice: piper | kokoro | elevenlabs | cartesiatext to speech of the answers (←→: what each one handles); an engine failing (no key, quota, model missing): Piper
Voices of the engine
voice.say_voices
textits voice per language: fr=ff_siwis, en=bf_emma (voice-tts --list <engine>); another engine for a language: es=kokoro:ef_dora; a language missing: the default voice of the engine
French voice (Piper)
voice.voice_fr
textPiper voice of the French answers (engine piper, the fallback of the others)
English voice (Piper)
voice.voice_en
textPiper voice of the English answers (engine piper, the fallback of the others)
Listen command
voice.listen_command ↻
textspeech to text (one JSON per sentence)
Say command
voice.say_command
texttext to speech
Speech recognition
voice.listen_model
choice: | parakeet | whisper | kroko-fr | groq | deepgramspeech to text (←→: what each one handles): local models, or the free-tier APIs groq / deepgram (their key: claude-cluster auth login groq); an API failing: the local model
Language spoken
voice.listen_language
textfor whisper / groq / deepgram: fr, en...; empty: found by the model (deepgram: multi, languages mixed)
End of a sentence (seconds)
voice.end_silence
floatthe silence that ends a sentence (0: 1.0); a short pause goes on the same one
Voice words file
voice.words
textthe cancel / send words said alone while a transcription waits; empty: voice-words.txt
Voice words (edit)
voice.edit_words
actionopens it in the editor: one word per line under [cancel] / [send]
Vocabulary file
voice.vocabulary
textproper names written back in what is heard (+ sessions, projects, your names); empty: vocabulary.txt of the config folder
Vocabulary (edit)
voice.edit_vocabulary
actionopens it in the editor: one name per line, "name = how it is heard, ..."
RéglageTypeRôle
Enabled
voice.enabled ↻
boolvoice of the global session (voice-listen / voice-say)
Listening
voice.mode ↻
choice: push | auto | wakepush-to-talk key, always, or after the wake phrase
Microphone
voice.source
textPulseAudio / PipeWire source of the wake phrase heard while claude-cluster is closed (Services > Service), empty: the default one
Wake phrase
voice.wake_word
textwake mode, variants separated by commas (ok claude, okay claude)
Armed (seconds)
voice.wake_seconds
intthe phrase alone: the next sentence within this time is the command
Spoken when armed
voice.wake_reply
textex: Oui ? (empty: silent)
Only my voice
voice.only_me ↻
boolvoice-listen --only-me (needs voice-enroll)
Confirmation (seconds)
voice.confirm_seconds
intthe transcription is shown this long before it is sent
Spoken answers
voice.speak
boolshort summary of the answers of the global session
Summary length
voice.summary_chars
intcharacters of the spoken summary
Speech engine
voice.say_engine
choice: piper | kokoro | elevenlabs | cartesiatext to speech of the answers (←→: what each one handles); an engine failing (no key, quota, model missing): Piper
Voices of the engine
voice.say_voices
textits voice per language: fr=ff_siwis, en=bf_emma (voice-tts --list <engine>); another engine for a language: es=kokoro:ef_dora; a language missing: the default voice of the engine
French voice (Piper)
voice.voice_fr
textPiper voice of the French answers (engine piper, the fallback of the others)
English voice (Piper)
voice.voice_en
textPiper voice of the English answers (engine piper, the fallback of the others)
Listen command
voice.listen_command ↻
textspeech to text (one JSON per sentence)
Say command
voice.say_command
texttext to speech
Speech recognition
voice.listen_model
choice: | parakeet | whisper | kroko-fr | groq | deepgramspeech to text (←→: what each one handles): local models, or the free-tier APIs groq / deepgram (their key: claude-cluster auth login groq); an API failing: the local model
Language spoken
voice.listen_language
textfor whisper / groq / deepgram: fr, en...; empty: found by the model (deepgram: multi, languages mixed)
End of a sentence (seconds)
voice.end_silence
floatthe silence that ends a sentence (0: 1.0); a short pause goes on the same one
Voice words file
voice.words
textthe cancel / send words said alone while a transcription waits; empty: voice-words.txt
Voice words (edit)
voice.edit_words
actionopens it in the editor: one word per line under [cancel] / [send]
Vocabulary file
voice.vocabulary
textproper names written back in what is heard (+ sessions, projects, your names); empty: vocabulary.txt of the config folder
Vocabulary (edit)
voice.edit_vocabulary
actionopens it in the editor: one name per line, "name = how it is heard, ..."

7. UserUtilisateur

SettingTypeWhat it does
Nickname
user.nickname
texthow the global session calls you
Contact email
user.email
textfor commits, messages the global session writes for you
Main editor
user.editor
textnvim, vim, code... (Ctrl+E too when [ui] editor is empty)
Language of the answers
user.language
choice: | fr | enempty: the one of each message
Notes
user.notes
textanything the global session should know about you
RéglageTypeRôle
Nickname
user.nickname
texthow the global session calls you
Contact email
user.email
textfor commits, messages the global session writes for you
Main editor
user.editor
textnvim, vim, code... (Ctrl+E too when [ui] editor is empty)
Language of the answers
user.language
choice: | fr | enempty: the one of each message
Notes
user.notes
textanything the global session should know about you

8. Web accessAccès web

SettingTypeWhat it does
Open the web access at start
web.enabled
boola browser or the app of a phone / another computer drives claude-cluster. • who: the devices of this network (same LAN); beyond it: Beyond the LAN • how: the address and the 6-digit code shown at the top (a click copies the code), then your yes here (a popup) • several at once; trusted: no code next time; banned: refused (devices › at the top, the palette: Web devices) • opened / closed live: the palette, Web access
Approve each new device
web.approve
boolafter its code, a new device waits for your yes here. • a popup: its name, its address, its browser; allow, allow and trust, deny • off: the code is enough on the LAN (from outside the LAN: always asked)
Port
web.port
intthe address shown: https://<this computer on the LAN>:<port>
Port outside
web.remote_port
introuter: the port opened on the router (0: the same as here)
Supervisor port
web.supervisor_port ↻
intthe web access of the supervisor (claude-cluster --supervisor, w): every claude-cluster of this computer at a glance in the page and the app, its own code and devices
Terminal page port
web.tty_port
intthe terminal interface of claude-cluster in a browser (its own port, the same code and approval): a real terminal of this computer, its keys, its mouse; the browser only (never the app); 0: off
Terminal page port outside
web.tty_remote_port
introuter: the port opened outside for the terminal page (0: the same)
Found by the app
web.discovery
boolthe app searching this network finds this computer by itself (its setup page: Search this network; its address changed: found again). • while the web access is open: an answer on UDP 8789 to the devices of this network only • told: its name, its port, the fingerprint of its authority - never its code (still asked, then your yes) • off: the address typed in the app
Beyond the LAN
web.remote
choice: off | tailscale | routerthe page reached away from home (the app goes there by itself when the LAN is not reached), encrypted end to end. tailscale (recommended: nothing open to the Internet) 1. install Tailscale here and on the phone, log in both with the same account 2. choose tailscale here: the address shown at the top becomes its tailnet one router (open to the Internet) 1. choose router: the port is opened on the router by UPnP (upnpc), else forward it yourself (TCP, Port outside → Port) 2. a changing public address: a dynamic DNS name in Name from outside Always from outside: each new device approved here, 5 wrong codes block its address 15 min, the bans apply
Name from outside
web.remote_host
textrouter: a dynamic DNS name pointing at your router (duckdns, no-ip...). • empty: its public address • put in the certificate (the browser checks it)
Shell from the page
web.shell
bool!command (and :r !command) typed in the web page or the app run on this computer. • in the folder of the session, like in the terminal • off (default): refused there - on, every device connected gets a shell of this computer, from outside the LAN too
Settings from the page
web.settings
listthe sections of the settings a device of the web page (the app) may change; empty (default): none, the settings read only there (This device stays its own). • sections: ui, notify, agent, commands, global, sessions, voice, user, service, web, mcp, services (the actions of the Services tab: start / stop, open / close, restart...) • all: every one (web itself: never this option from the page)
HTTPS
web.https
boolTLS with a certificate of its own, made once. • the conversation and the code encrypted, the microphone of the page allowed • the browser asks to accept it the first time (or: the palette, Web access: trust its certificate) • off: plain http, no microphone
RéglageTypeRôle
Open the web access at start
web.enabled
boola browser or the app of a phone / another computer drives claude-cluster. • who: the devices of this network (same LAN); beyond it: Beyond the LAN • how: the address and the 6-digit code shown at the top (a click copies the code), then your yes here (a popup) • several at once; trusted: no code next time; banned: refused (devices › at the top, the palette: Web devices) • opened / closed live: the palette, Web access
Approve each new device
web.approve
boolafter its code, a new device waits for your yes here. • a popup: its name, its address, its browser; allow, allow and trust, deny • off: the code is enough on the LAN (from outside the LAN: always asked)
Port
web.port
intthe address shown: https://<this computer on the LAN>:<port>
Port outside
web.remote_port
introuter: the port opened on the router (0: the same as here)
Supervisor port
web.supervisor_port ↻
intthe web access of the supervisor (claude-cluster --supervisor, w): every claude-cluster of this computer at a glance in the page and the app, its own code and devices
Terminal page port
web.tty_port
intthe terminal interface of claude-cluster in a browser (its own port, the same code and approval): a real terminal of this computer, its keys, its mouse; the browser only (never the app); 0: off
Terminal page port outside
web.tty_remote_port
introuter: the port opened outside for the terminal page (0: the same)
Found by the app
web.discovery
boolthe app searching this network finds this computer by itself (its setup page: Search this network; its address changed: found again). • while the web access is open: an answer on UDP 8789 to the devices of this network only • told: its name, its port, the fingerprint of its authority - never its code (still asked, then your yes) • off: the address typed in the app
Beyond the LAN
web.remote
choice: off | tailscale | routerthe page reached away from home (the app goes there by itself when the LAN is not reached), encrypted end to end. tailscale (recommended: nothing open to the Internet) 1. install Tailscale here and on the phone, log in both with the same account 2. choose tailscale here: the address shown at the top becomes its tailnet one router (open to the Internet) 1. choose router: the port is opened on the router by UPnP (upnpc), else forward it yourself (TCP, Port outside → Port) 2. a changing public address: a dynamic DNS name in Name from outside Always from outside: each new device approved here, 5 wrong codes block its address 15 min, the bans apply
Name from outside
web.remote_host
textrouter: a dynamic DNS name pointing at your router (duckdns, no-ip...). • empty: its public address • put in the certificate (the browser checks it)
Shell from the page
web.shell
bool!command (and :r !command) typed in the web page or the app run on this computer. • in the folder of the session, like in the terminal • off (default): refused there - on, every device connected gets a shell of this computer, from outside the LAN too
Settings from the page
web.settings
listthe sections of the settings a device of the web page (the app) may change; empty (default): none, the settings read only there (This device stays its own). • sections: ui, notify, agent, commands, global, sessions, voice, user, service, web, mcp, services (the actions of the Services tab: start / stop, open / close, restart...) • all: every one (web itself: never this option from the page)
HTTPS
web.https
boolTLS with a certificate of its own, made once. • the conversation and the code encrypted, the microphone of the page allowed • the browser asks to accept it the first time (or: the palette, Web access: trust its certificate) • off: plain http, no microphone

9. AttachmentsPièces jointes

SettingTypeWhat it does
Attachments
attachments.enabled
boolfiles, images and photos attached to a prompt (the paperclip, a drop, a paste; the app: the camera)
Largest file (MB)
attachments.max_mb
inta bigger file is refused
Files per prompt
attachments.max_files
intat most this many attached to one prompt
Kept per session
attachments.keep
intthe oldest attachments of a session go past this many (0: all kept); all of them go when the session is deleted
Downscale images above (px)
attachments.max_pixels
inta photo larger than this side is reduced before it is stored and sent (0: as it is); needs ImageMagick (magick)
Strip the EXIF of images
attachments.strip_exif
boolphotos re-encoded without their metadata (GPS position, camera, date); needs ImageMagick (magick)
Stored in
attachments.dir
textthe folder of the attachments, one folder per session (empty: <data>/attachments)
Allow link mode
attachments.link
boola file of this computer linked by its path, nothing copied (window, terminal, a page opened on this computer); a phone or another computer always uploads
The global session may attach
attachments.global
boolit may attach a local file to a prompt it sends (MCP session_send attachments): the project folder of the session and the home of the user only (no hidden folder of the home, nothing of claude-cluster itself)
Files per prompt of the global session
attachments.global_max
intat most this many
RéglageTypeRôle
Attachments
attachments.enabled
boolfiles, images and photos attached to a prompt (the paperclip, a drop, a paste; the app: the camera)
Largest file (MB)
attachments.max_mb
inta bigger file is refused
Files per prompt
attachments.max_files
intat most this many attached to one prompt
Kept per session
attachments.keep
intthe oldest attachments of a session go past this many (0: all kept); all of them go when the session is deleted
Downscale images above (px)
attachments.max_pixels
inta photo larger than this side is reduced before it is stored and sent (0: as it is); needs ImageMagick (magick)
Strip the EXIF of images
attachments.strip_exif
boolphotos re-encoded without their metadata (GPS position, camera, date); needs ImageMagick (magick)
Stored in
attachments.dir
textthe folder of the attachments, one folder per session (empty: <data>/attachments)
Allow link mode
attachments.link
boola file of this computer linked by its path, nothing copied (window, terminal, a page opened on this computer); a phone or another computer always uploads
The global session may attach
attachments.global
boolit may attach a local file to a prompt it sends (MCP session_send attachments): the project folder of the session and the home of the user only (no hidden folder of the home, nothing of claude-cluster itself)
Files per prompt of the global session
attachments.global_max
intat most this many

10. MCPMCP

SettingTypeWhat it does
Custom MCP servers
mcp.servers ↻
listmore tools for the global session (MCP servers), comma separated. • a local program: name: command args (stdio; env VAR=value command... for its variables) e.g. files: npx -y @modelcontextprotocol/server-filesystem ~/notes • a site: name: https://url (HTTP) • its tools: mcp__<name>__*, on / off one by one in this MCP page Applied at the next start of the global session
RéglageTypeRôle
Custom MCP servers
mcp.servers ↻
listmore tools for the global session (MCP servers), comma separated. • a local program: name: command args (stdio; env VAR=value command... for its variables) e.g. files: npx -y @modelcontextprotocol/server-filesystem ~/notes • a site: name: https://url (HTTP) • its tools: mcp__<name>__*, on / off one by one in this MCP page Applied at the next start of the global session

11. UsageUsage

SettingTypeWhat it does
Account windows
usage.account
boolthe 5 h / 7 d windows of the Claude account logged in here (the usage endpoint of claude.ai, the token of Claude Code: ~/.claude/.credentials.json, never shown), read again once too old (Account refresh) and after each turn; off: the ones the last turn told only
Account refresh (s)
usage.account_refresh
intthe account windows read again past this age (30 to 3600 s); one read shared by every instance of this user (~/.cache/claude-cluster/account-usage.json): an independent instance or a second core reads the one already made
Claude Code transcripts
usage.transcripts
listthe folders of the transcripts of Claude Code (~/.claude/projects): every answer's usage (the API's own numbers: input, cache written / read, output, thinking) summed by day and model, every session of this computer - in claude-cluster or not; empty: the ledger of claude-cluster's own sessions only. The prices: [usage.prices] in config.toml (model = $ per million input tokens), else the ones learned from the cost Claude Code tells, else the public table
RéglageTypeRôle
Account windows
usage.account
boolthe 5 h / 7 d windows of the Claude account logged in here (the usage endpoint of claude.ai, the token of Claude Code: ~/.claude/.credentials.json, never shown), read again once too old (Account refresh) and after each turn; off: the ones the last turn told only
Account refresh (s)
usage.account_refresh
intthe account windows read again past this age (30 to 3600 s); one read shared by every instance of this user (~/.cache/claude-cluster/account-usage.json): an independent instance or a second core reads the one already made
Claude Code transcripts
usage.transcripts
listthe folders of the transcripts of Claude Code (~/.claude/projects): every answer's usage (the API's own numbers: input, cache written / read, output, thinking) summed by day and model, every session of this computer - in claude-cluster or not; empty: the ledger of claude-cluster's own sessions only. The prices: [usage.prices] in config.toml (model = $ per million input tokens), else the ones learned from the cost Claude Code tells, else the public table

12. DebugDébogage

SettingTypeWhat it does
Show everything
debug.showcase_all
actionevery popup below in a row (the sounds apart), on this interface: the display blocks in the showcase session, its states, a progress popup, a failure popup, a notification, a permission, the questions (QCM, Q&A, chat, review)
Display blocks
debug.showcase_displays
actionmarkdown, callouts, code, table, charts (bar, line, pie), progress, metrics, heatmap, image, svg, diagram, diff, json, tree, terminal, checklist, steps, timeline, kanban, buttons, form, details, compare, math, audio, files - and how this platform draws each one
Questions popup
debug.showcase_questions
actionthe questions of an agent: a single choice, a multiple choice, a free answer (Other), the chat about them, back / next, the review before Submit / Cancel - answered here, sent to nobody
Questions with previews
debug.showcase_previews
actiona question whose options carry a preview beside the list: markdown, a coloured diff, a table, a chart, a mock-up and a picture - answered here, sent to nobody
Update popup
debug.showcase_upgrade
actionthe popup of a newer claude-cluster installed (Update / Ignore / Quit with the arrows and Enter): a pretend version, nothing is installed or stopped
Permission popup
debug.showcase_permission
actiona permission asked by an agent (Allow / Always / Deny): nothing is run
Session states
debug.showcase_states
actionthe showcase session working, waiting, in error, idle: its icon, the title of the terminal / window / tab, the face
Progress popup
debug.showcase_progress
actiona long action: its steps, its log scrolling, then done
Failure popup
debug.showcase_failure
actionan action that failed: what went wrong, OK / Retry
Notifications
debug.showcase_notify
actiona desktop / phone notification and the notices (information, error)
Sounds: all of them
debug.sound_all
actionevery sound of the notifications, one after the other, on this computer (whatever With a sound says): what you hear when something happens
Sound: a turn done
debug.sound_message
actionmessage: a turn done, a message
Sound: a job done
debug.sound_complete
actioncomplete: a heavy job done
Sound: for you
debug.sound_message-new-instant
actionmessage-new-instant: a question, a permission, a reminder
Sound: a problem
debug.sound_dialog-warning
actiondialog-warning: an error, a dangerous permission, a job failed
Sound: ready
debug.sound_service-login
actionservice-login: claude-cluster ready, a device connected
RéglageTypeRôle
Show everything
debug.showcase_all
actionevery popup below in a row (the sounds apart), on this interface: the display blocks in the showcase session, its states, a progress popup, a failure popup, a notification, a permission, the questions (QCM, Q&A, chat, review)
Display blocks
debug.showcase_displays
actionmarkdown, callouts, code, table, charts (bar, line, pie), progress, metrics, heatmap, image, svg, diagram, diff, json, tree, terminal, checklist, steps, timeline, kanban, buttons, form, details, compare, math, audio, files - and how this platform draws each one
Questions popup
debug.showcase_questions
actionthe questions of an agent: a single choice, a multiple choice, a free answer (Other), the chat about them, back / next, the review before Submit / Cancel - answered here, sent to nobody
Questions with previews
debug.showcase_previews
actiona question whose options carry a preview beside the list: markdown, a coloured diff, a table, a chart, a mock-up and a picture - answered here, sent to nobody
Update popup
debug.showcase_upgrade
actionthe popup of a newer claude-cluster installed (Update / Ignore / Quit with the arrows and Enter): a pretend version, nothing is installed or stopped
Permission popup
debug.showcase_permission
actiona permission asked by an agent (Allow / Always / Deny): nothing is run
Session states
debug.showcase_states
actionthe showcase session working, waiting, in error, idle: its icon, the title of the terminal / window / tab, the face
Progress popup
debug.showcase_progress
actiona long action: its steps, its log scrolling, then done
Failure popup
debug.showcase_failure
actionan action that failed: what went wrong, OK / Retry
Notifications
debug.showcase_notify
actiona desktop / phone notification and the notices (information, error)
Sounds: all of them
debug.sound_all
actionevery sound of the notifications, one after the other, on this computer (whatever With a sound says): what you hear when something happens
Sound: a turn done
debug.sound_message
actionmessage: a turn done, a message
Sound: a job done
debug.sound_complete
actioncomplete: a heavy job done
Sound: for you
debug.sound_message-new-instant
actionmessage-new-instant: a question, a permission, a reminder
Sound: a problem
debug.sound_dialog-warning
actiondialog-warning: an error, a dangerous permission, a job failed
Sound: ready
debug.sound_service-login
actionservice-login: claude-cluster ready, a device connected

13. ServicesServices

SettingTypeWhat it does
Refresh
services.refresh
choice: live | interval | manuallive: what changes shown at once (the voice heard, the web, the sessions), the slow parts (systemd, its journal, tailscale) read every Delay; interval: everything every Delay; manual: R reads it again (and after each action)
Delay (s)
services.delay
intseconds between two reads (interval), the slow parts kept so long (live)
Service (systemd)
services.svc_service
actionthe service of your session (systemd --user): it listens for the wake phrase while claude-cluster is closed and opens it when heard. • Setup: its unit written · Enable: started now and with your session · Disable: stopped, not started any more • Start / Stop / Restart: now only · Remove: its unit and its detector removed Its detector is paused while claude-cluster runs (the microphone is the voice's of the core): what is heard now is under Voice
Web access
services.svc_web
actionthe web page and the app of the phone: open / close it now (Open the web access at start: at the start), a new code (the devices connected stay), the router asked again (Beyond the LAN)
Core
services.svc_core
actionthe process that runs the sessions, shared by the terminals and windows (Several terminals / windows at once). • Restart: it stops, its terminals / windows start it again, the sessions resumed (their conversations kept) • Stop all: the core and every terminal / window closed
Processes and version
services.svc_processes
actionwhat claude-cluster runs now: its version (this interface and the core), since when, the changes of the last versions; the memory of the core, of each interface and of each session with what it started (its shells, its MCP servers), the tokens of this launch. • Stop the shells of a session (or every shell): the shells it runs in the background stopped, the session goes on
Voice
services.svc_voice
actionthe voice of the core: listening or not, what it hears now (what is being said, the transcriptions waiting), what it misses
Update
services.svc_update
actionthe version running and the one installed on disk (./setup.sh install claude-cluster): a newer one is offered in a popup (Update / Ignore / Quit); ignored, it comes back here. • Update now: the smooth update (the turns end first, the sessions kept) • Offer it again: its popup back (no longer ignored) • Check again: the binary on disk read again (also /update)
MCP servers
services.svc_mcp
actionthe MCP servers given to the global session (MCP > Custom MCP servers): Restart the global session to load them again
Outside (router / tailscale)
services.svc_outside
actionhow the web access is reached from outside (Web > Beyond the LAN): ask the router again (UPnP), remove its redirection, log this computer in to tailscale
RéglageTypeRôle
Refresh
services.refresh
choice: live | interval | manuallive: what changes shown at once (the voice heard, the web, the sessions), the slow parts (systemd, its journal, tailscale) read every Delay; interval: everything every Delay; manual: R reads it again (and after each action)
Delay (s)
services.delay
intseconds between two reads (interval), the slow parts kept so long (live)
Service (systemd)
services.svc_service
actionthe service of your session (systemd --user): it listens for the wake phrase while claude-cluster is closed and opens it when heard. • Setup: its unit written · Enable: started now and with your session · Disable: stopped, not started any more • Start / Stop / Restart: now only · Remove: its unit and its detector removed Its detector is paused while claude-cluster runs (the microphone is the voice's of the core): what is heard now is under Voice
Web access
services.svc_web
actionthe web page and the app of the phone: open / close it now (Open the web access at start: at the start), a new code (the devices connected stay), the router asked again (Beyond the LAN)
Core
services.svc_core
actionthe process that runs the sessions, shared by the terminals and windows (Several terminals / windows at once). • Restart: it stops, its terminals / windows start it again, the sessions resumed (their conversations kept) • Stop all: the core and every terminal / window closed
Processes and version
services.svc_processes
actionwhat claude-cluster runs now: its version (this interface and the core), since when, the changes of the last versions; the memory of the core, of each interface and of each session with what it started (its shells, its MCP servers), the tokens of this launch. • Stop the shells of a session (or every shell): the shells it runs in the background stopped, the session goes on
Voice
services.svc_voice
actionthe voice of the core: listening or not, what it hears now (what is being said, the transcriptions waiting), what it misses
Update
services.svc_update
actionthe version running and the one installed on disk (./setup.sh install claude-cluster): a newer one is offered in a popup (Update / Ignore / Quit); ignored, it comes back here. • Update now: the smooth update (the turns end first, the sessions kept) • Offer it again: its popup back (no longer ignored) • Check again: the binary on disk read again (also /update)
MCP servers
services.svc_mcp
actionthe MCP servers given to the global session (MCP > Custom MCP servers): Restart the global session to load them again
Outside (router / tailscale)
services.svc_outside
actionhow the web access is reached from outside (Web > Beyond the LAN): ask the router again (UPnP), remove its redirection, log this computer in to tailscale

14. PluginsPlugins

SettingTypeWhat it does
+ Add a source
plugins.plugsrc_add
actiona repository (GitHub owner/repo, an https URL), a folder of this computer (~/... or /...), a .zip (a path; dropped on the terminal: its path). • a Claude Code marketplace (.claude-plugin/marketplace.json): its plugins (claude plugin install) • else its skills (the folders with a SKILL.md): linked in ~/.claude/skills Code of these sources runs as you: only sources you trust
Sync every (hours)
plugins.sync_hours
intthe sources with auto sync pulled again every N hours (and at each start of the core); 0: at the start only. A source with auto sync off is pulled only by hand (Sync in its page)
RéglageTypeRôle
+ Add a source
plugins.plugsrc_add
actiona repository (GitHub owner/repo, an https URL), a folder of this computer (~/... or /...), a .zip (a path; dropped on the terminal: its path). • a Claude Code marketplace (.claude-plugin/marketplace.json): its plugins (claude plugin install) • else its skills (the folders with a SKILL.md): linked in ~/.claude/skills Code of these sources runs as you: only sources you trust
Sync every (hours)
plugins.sync_hours
intthe sources with auto sync pulled again every N hours (and at each start of the core); 0: at the start only. A source with auto sync off is pulled only by hand (Sync in its page)

15. ProfilesProfiles

SettingTypeWhat it does
Profiles
profiles.svc_profiles
actiona profile keeps every setting of now under the name you choose; Apply puts them back on every claude-cluster of this computer (they share config.toml and read it again when it changes), Undo brings back the settings before. Archive keeps one apart, Delete puts it in the trash for days (Restore), then it goes for good
RéglageTypeRôle
Profiles
profiles.svc_profiles
actiona profile keeps every setting of now under the name you choose; Apply puts them back on every claude-cluster of this computer (they share config.toml and read it again when it changes), Undo brings back the settings before. Archive keeps one apart, Delete puts it in the trash for days (Restore), then it goes for good

16. Accounts and limitsComptes et limites

SettingTypeWhat it does
Limit per day (USD)
limits.daily_usd
floatwhat all the sessions may spend since the local midnight; 0: none. Reached: the prompts are refused (Block) and you are notified; warned at the share of Warn at
Limit per week (USD)
limits.weekly_usd
floatthe last 7 days; 0: none
Limit per month (USD)
limits.monthly_usd
floatsince the 1st of the local month; 0: none
Counted
limits.scope
choice: keys | allwhat the limits count. • keys: only the turns billed through an API key (openrouter, anthropic-api...): a subscription costs nothing more per turn • all: every turn, the notional cost of a subscription too (the price of its tokens)
Block at the limit
limits.block
booltrue: a limit reached refuses the new prompts (send --force passes); false: only warned
Warn at (%)
limits.warn_percent
intwarned (a notice and a notification) at this share of a limit; 0: only when it is reached
RéglageTypeRôle
Limit per day (USD)
limits.daily_usd
floatwhat all the sessions may spend since the local midnight; 0: none. Reached: the prompts are refused (Block) and you are notified; warned at the share of Warn at
Limit per week (USD)
limits.weekly_usd
floatthe last 7 days; 0: none
Limit per month (USD)
limits.monthly_usd
floatsince the 1st of the local month; 0: none
Counted
limits.scope
choice: keys | allwhat the limits count. • keys: only the turns billed through an API key (openrouter, anthropic-api...): a subscription costs nothing more per turn • all: every turn, the notional cost of a subscription too (the price of its tokens)
Block at the limit
limits.block
booltrue: a limit reached refuses the new prompts (send --force passes); false: only warned
Warn at (%)
limits.warn_percent
intwarned (a notice and a notification) at this share of a limit; 0: only when it is reached

17. Accounts and limitsComptes et limites

SettingTypeWhat it does
spent today
accounts.spent_day
actionthe spending of today (the usage ledger, the scope below)
spent this week
accounts.spent_week
actionthe last 7 days
spent this month
accounts.spent_month
actionsince the 1st of the month
RéglageTypeRôle
spent today
accounts.spent_day
actionthe spending of today (the usage ledger, the scope below)
spent this week
accounts.spent_week
actionthe last 7 days
spent this month
accounts.spent_month
actionsince the 1st of the month

18. Model policyPolitique des modèles

SettingTypeWhat it does
Default model of the sub-sessions
policy.default_model
textthe model the sub-sessions start from (opus, sonnet, haiku, an id...); empty: none. The global session chooses the model of each sub-session by the difficulty of its task, from this one
Model: how the default applies
policy.model_mode
choicefree: no default | advise: the default is the start, deviate for a reason | force: nothing else is allowed (refused, with the reason)
Default thinking of the sub-sessions
policy.default_effort
choicethe thinking effort they start from (empty: the default of the agent)
Thinking: how the default applies
policy.effort_mode
choicefree | advise | force, like the model
Allowed models
policy.allowed_models
listthe only models the global session may choose, comma separated (a name or a part: haiku, sonnet); empty: every one
Allowed thinking efforts
policy.allowed_efforts
listthe only efforts it may choose, comma separated; empty: every one
Ask before a costly choice
policy.ask_costly
booltrue: the global session asks you (a popup: Allow / Deny, on every interface and a notification) before running a session on a costly model or thinking effort (below); false: it chooses alone inside the limits above
Costly models
policy.costly_models
listmodels that cost as much or more than these (a name or a part: opus, fable)
Costly thinking efforts
policy.costly_efforts
listefforts of this level or above (xhigh, max)
RéglageTypeRôle
Default model of the sub-sessions
policy.default_model
textthe model the sub-sessions start from (opus, sonnet, haiku, an id...); empty: none. The global session chooses the model of each sub-session by the difficulty of its task, from this one
Model: how the default applies
policy.model_mode
choicefree: no default | advise: the default is the start, deviate for a reason | force: nothing else is allowed (refused, with the reason)
Default thinking of the sub-sessions
policy.default_effort
choicethe thinking effort they start from (empty: the default of the agent)
Thinking: how the default applies
policy.effort_mode
choicefree | advise | force, like the model
Allowed models
policy.allowed_models
listthe only models the global session may choose, comma separated (a name or a part: haiku, sonnet); empty: every one
Allowed thinking efforts
policy.allowed_efforts
listthe only efforts it may choose, comma separated; empty: every one
Ask before a costly choice
policy.ask_costly
booltrue: the global session asks you (a popup: Allow / Deny, on every interface and a notification) before running a session on a costly model or thinking effort (below); false: it chooses alone inside the limits above
Costly models
policy.costly_models
listmodels that cost as much or more than these (a name or a part: opus, fable)
Costly thinking efforts
policy.costly_efforts
listefforts of this level or above (xhigh, max)

19. OrchestratorOrchestrateur

SettingTypeWhat it does
Profile
orchestrator.profile
choice: low | normal | maxhow much of the computer the jobs take • low: 1 thread per job, nice 19, ionice idle, half the usable cores at once • normal: 2-4 threads, nice 10, one job per usable core • max: the share of cores, nice 5, 1.5 jobs per core
When one is detected
orchestrator.detect_action
choice: off | notice | tellnotice: a notice and the jobs list; tell: its session gets a prompt too
Orchestrator
orchestrator.enabled
boolthe heavy jobs of the sessions (builds, tests, containers / media / GPU) wait in a queue and take turns: cluster-run, heavy_run, jobs_add. Off: cluster-run runs its command at once
Memory guard
orchestrator.memory_guard
boolevery second, under the memory kept free, the biggest of what claude-cluster runs is killed - a command of a session (its shells, background tasks, agents), a heavy job, at worst an agent grown abnormal; never the core - before the system kills anything itself; its session is told what and why (run it again with less memory), with a notice and a notification
Kill on out-of-memory
orchestrator.kill_on_oom
boolunder the out-of-memory threshold the newest job is killed (never by default: the jobs are only slowed)
Sub-sessions may add jobs (MCP)
orchestrator.sub_add
boolheavy_run, jobs_add for the sub-sessions: off by default, nothing asks the permission of their mode on this path (their shell cluster-run is not concerned)
Sub-sessions may kill their jobs
orchestrator.sub_kill_own
booljob_kill on their own jobs
Sub-sessions see the other jobs
orchestrator.sub_see_others
booljobs_list / job_status of the jobs of the other sessions
Notify a killed job
orchestrator.notify_killed
boola notification (desktop, app) when a job is killed
Notify a finished job
orchestrator.notify_done
boola notification (desktop, app) when a job finishes
Heavy jobs at once
orchestrator.max_jobs
intrunning at once (0: from the hardware, the profile, the live load and memory)
Jobs per session
orchestrator.max_per_session
intrunning at once for one session (0: no limit)
Cores left to me
orchestrator.reserved_cpu
intkept free for you and the interface
Memory left to me (MB)
orchestrator.reserved_ram_mb
intkept free for you and the interface
Threads per job
orchestrator.threads
intthe parallelism granted to a job (-j, --parallel, CARGO_BUILD_JOBS...); 0: from the profile (low: 1)
Aging (seconds)
orchestrator.aging_seconds
inta waiting job gains one point every so many seconds, a priority step is 10: nothing starves
Session shown first
orchestrator.focus_boost
intpoints of the session you look at: its jobs go first
Detect heavy commands (CPU s)
orchestrator.detect_cpu_seconds
inta command outside the queue that burned this many CPU seconds is listed and told (0: off)
Hold: memory available (MB)
orchestrator.hold_mem_mb
intbelow it nothing new starts
Reduce: memory available (MB)
orchestrator.reduce_mem_mb
intbelow it the running jobs are slowed
Out of memory (MB)
orchestrator.oom_mem_mb
intbelow it, with Kill on out-of-memory, the newest job is killed
Hold: swap used (MB)
orchestrator.hold_swap_mb
intabove it, with the memory short too, nothing new starts
Resume after (seconds)
orchestrator.resume_after
intcalm for so long before the stopped jobs resume (hysteresis)
Memory kept free (MB)
orchestrator.guard_free_mb
intthe memory guard acts below it (0: 5 % of the RAM, at least 500 MB)
Smallest command killed (MB)
orchestrator.guard_min_mb
inta command using less is never the one the memory guard kills
Finished jobs kept
orchestrator.history
intthe list of the finished jobs
Heavy commands
orchestrator.patterns
listmore commands that go through the queue, comma separated: "text" (class custom) or "text = class" (build, tests, container, gpu, custom); a command containing it is heavy
Session priorities
orchestrator.session_prio
list"s3=5": the jobs of a session come first (higher) or last (negative)
Session quotas
orchestrator.session_quota
list"s3=1": jobs of a session running at once
RéglageTypeRôle
Profile
orchestrator.profile
choice: low | normal | maxhow much of the computer the jobs take • low: 1 thread per job, nice 19, ionice idle, half the usable cores at once • normal: 2-4 threads, nice 10, one job per usable core • max: the share of cores, nice 5, 1.5 jobs per core
When one is detected
orchestrator.detect_action
choice: off | notice | tellnotice: a notice and the jobs list; tell: its session gets a prompt too
Orchestrator
orchestrator.enabled
boolthe heavy jobs of the sessions (builds, tests, containers / media / GPU) wait in a queue and take turns: cluster-run, heavy_run, jobs_add. Off: cluster-run runs its command at once
Memory guard
orchestrator.memory_guard
boolevery second, under the memory kept free, the biggest of what claude-cluster runs is killed - a command of a session (its shells, background tasks, agents), a heavy job, at worst an agent grown abnormal; never the core - before the system kills anything itself; its session is told what and why (run it again with less memory), with a notice and a notification
Kill on out-of-memory
orchestrator.kill_on_oom
boolunder the out-of-memory threshold the newest job is killed (never by default: the jobs are only slowed)
Sub-sessions may add jobs (MCP)
orchestrator.sub_add
boolheavy_run, jobs_add for the sub-sessions: off by default, nothing asks the permission of their mode on this path (their shell cluster-run is not concerned)
Sub-sessions may kill their jobs
orchestrator.sub_kill_own
booljob_kill on their own jobs
Sub-sessions see the other jobs
orchestrator.sub_see_others
booljobs_list / job_status of the jobs of the other sessions
Notify a killed job
orchestrator.notify_killed
boola notification (desktop, app) when a job is killed
Notify a finished job
orchestrator.notify_done
boola notification (desktop, app) when a job finishes
Heavy jobs at once
orchestrator.max_jobs
intrunning at once (0: from the hardware, the profile, the live load and memory)
Jobs per session
orchestrator.max_per_session
intrunning at once for one session (0: no limit)
Cores left to me
orchestrator.reserved_cpu
intkept free for you and the interface
Memory left to me (MB)
orchestrator.reserved_ram_mb
intkept free for you and the interface
Threads per job
orchestrator.threads
intthe parallelism granted to a job (-j, --parallel, CARGO_BUILD_JOBS...); 0: from the profile (low: 1)
Aging (seconds)
orchestrator.aging_seconds
inta waiting job gains one point every so many seconds, a priority step is 10: nothing starves
Session shown first
orchestrator.focus_boost
intpoints of the session you look at: its jobs go first
Detect heavy commands (CPU s)
orchestrator.detect_cpu_seconds
inta command outside the queue that burned this many CPU seconds is listed and told (0: off)
Hold: memory available (MB)
orchestrator.hold_mem_mb
intbelow it nothing new starts
Reduce: memory available (MB)
orchestrator.reduce_mem_mb
intbelow it the running jobs are slowed
Out of memory (MB)
orchestrator.oom_mem_mb
intbelow it, with Kill on out-of-memory, the newest job is killed
Hold: swap used (MB)
orchestrator.hold_swap_mb
intabove it, with the memory short too, nothing new starts
Resume after (seconds)
orchestrator.resume_after
intcalm for so long before the stopped jobs resume (hysteresis)
Memory kept free (MB)
orchestrator.guard_free_mb
intthe memory guard acts below it (0: 5 % of the RAM, at least 500 MB)
Smallest command killed (MB)
orchestrator.guard_min_mb
inta command using less is never the one the memory guard kills
Finished jobs kept
orchestrator.history
intthe list of the finished jobs
Heavy commands
orchestrator.patterns
listmore commands that go through the queue, comma separated: "text" (class custom) or "text = class" (build, tests, container, gpu, custom); a command containing it is heavy
Session priorities
orchestrator.session_prio
list"s3=5": the jobs of a session come first (higher) or last (negative)
Session quotas
orchestrator.session_quota
list"s3=1": jobs of a session running at once