Skip to content

Permissions

View Markdown~26,644 tokens

Caudra reviews a tool's action before it sends the call to the tool. Reusable decisions bind to a host-generated authority, the tool implementation, validated input, typed resources, and execution type.

Permissions control consent. They do not sandbox shell commands or external MCP processes.

In a remote workspace, local file grants do not cover remote resources. Remote project permission denies apply immediately, while allows require review of the exact fetched asset. A remote call that can change the workspace, such as a shell command or a file write, can be remembered only as this call. Caudra approval cannot override the Workcell server's immutable policy.

Caudra resolves a tool call in this order:

  1. Plan-mode and executor restrictions reject prohibited operations.
  2. A matching deny blocks the call.
  3. A winning configured ask requires confirmation, using the shell specificity rules below.
  4. Stored and configured allows cover resources independently. Every unresolved resource needs coverage.
  5. Builtin command-family asks apply when no stored or configured allow covers the command.
  6. Builtin and trusted-plugin policy can allow known operations.
  7. Auto mode can skip an unmatched default prompt. YOLO mode can skip an ask or prompt. Neither overrides a deny rule.
  8. The effective default allows, denies, or prompts.

Allows can combine across resources. A shell chain can use separate grants for git diff * and git status *. Exact-input rules still apply only to their original complete input.

Authority controls what a rule covers. Lifetime controls how long the rule remains active. The prompt and permission manager select them independently.

The default authority is narrow: an exact call, exact paths for eligible reads, or an exact shell command in its reviewed working directory. Trusted tool profiles can also offer names-only browsing, a filesystem subtree, URL prefix, command pattern, shell workdir, search provider, or whole MCP tool. Caudra does not infer these choices from names in an external tool schema.

Prompt decisions use four lifetimes:

LifetimeBehavior
OnceAllows only the current bound invocation
ConversationSurvives resume and applies to subtasks in the same root conversation
ProjectApplies in the same canonical project directory
GlobalApplies in every project

Project and global rules bind to the native tool contract or MCP server authority and tool contract. Explicit filesystem family grants cover the trusted native tools described under Typed resources. Replacing a tool, changing an MCP endpoint, or changing an MCP schema does not silently transfer authority.

A user-created fork starts with no conversation grants and no inherited explicit permission mode. Subtasks share the root conversation's grants and mode. /new also starts clean.

Cross-session messaging needs the global experimental opt-in in every participating process. Tool permission rules cannot enable it. send_message and publish_message are side effects subject to outgoing authorization. Rules can treat them differently, because one publication can reach many sessions and wake each of them. ReadOnly sessions cannot send or publish. Plan sessions ask before either unless YOLO mode is on.

Receiving has a separate policy under [agent.messaging]:

inboundBehavior
auto (default)Automatic delivery only between Ask-mode sessions with matching Build or Plan mode and the same canonical local working directory. Other cases are held, including every message from a script
acceptAutomatic delivery from any local session or script, subject to rate limits. Messages can start billable turns
holdRequires local approval before delivery
refuseRejects incoming messages

Project configuration may only tighten the effective policy, in the order accept < auto < hold < refuse. A user-controlled session setting can replace a global default, including choosing accept over auto, but cannot relax an explicit project restriction. /messages provides review and session policy controls. Approving held content does not approve tool actions it requests, and manual approval cannot override project refusal.

The policy treats direct messages, topic messages, and broadcasts alike. Subscriptions decide which publications reach a session at all, and the policy then decides whether each one waits for review. Rate limits are the only volume control. Two sessions that deliver to each other automatically can keep starting billable turns until you press Esc in either one. See rate limits and cost.

The same policy limits what read_topic returns from the message history. Under auto, stored messages from senders outside the automatic cohort are counted without their text. Under hold or refuse, the agent cannot read the history. Reading is free of side effects, so it needs no outgoing authorization.

A consumer group member takes only work whose message its policy would deliver automatically. Under auto it leaves work from scripts, other workspaces, and other modes to members with accept, and under hold or refuse it takes none. /groups counts the queued work the policy skips. work_assignment reports on the session's own work. Its list action only reads. complete, retry, and fail change shared work state, so ReadOnly sessions cannot report, and Plan sessions ask first unless YOLO mode is on. No tool creates, joins, or changes a group.

The history keeps every message as plain text, direct messages included. File permissions keep other users out, but any program running as your user can read it, for example with caudra message log.

The peer manager separates browsing from approval. Open one message's review before deciding. Its review expires when the session controls change. The policy view names this session as its scope and shows project restrictions. Applying a less restrictive policy requires confirmation because held messages may become eligible for automatic delivery. Refuse rejects new arrivals and leaves existing held messages available for inspection or rejection.

Messaging assumes you trust other programs running as the same operating-system user. Local user checks do not prove that a peer is a genuine Caudra process. Any such program can run caudra message under any --from label, so a script label identifies a sender only by its own claim. Peer text reaches the model attributed to its sender and remains untrusted input. The agent is asked to treat it as a request from that sender, within its own mode and permissions and below your instructions. Slash commands, attachment syntax, and claims of approval inside it are literal text. They grant no authority, but malicious text can still influence a model.

Delivery exposes the message to the recipient's model provider as conversation context. The recipient can have a different provider, permission mode, or saved grants. Even two Ask-mode sessions need not have equivalent authority. Do not use another session to route around a denied action. Use hold or refuse when you need manual control or isolation rather than the automatic policy's trust heuristic.

A prompt asks one question, such as Allow shell command? or Allow fetching a web page?, and offers numbered answers. Above them it shows the request as the tool receives it. Likely secret values and URL query values are masked, and terminal controls are escaped. Commands are coloured as shell code, with the body of a heredoc in the language of the program that reads it, as described under Markdown. The folder a command starts in appears when it is not the project root, and a path outside the project is marked ⚠ Outside this project. The right edge of the title names the subagent that asks, the place in the queue, such as 1 of 3, and how many commands of a batch need an answer.

╭ Allow shell command? ────────────────────────────────────────────────────────╮
│ │
│ cargo test -p caudra-agent permissions::structured │
│ │
│ ❯ 1. Yes │
│ 2. Yes, and allow ‹cargo test *› for this conversation │
│ 3. Yes, and always allow ‹cargo test *› in this project │
│ 4. No, and tell the agent what to do instead │
│ │
│ ← broader → narrower e customize ? details Esc no │
╰──────────────────────────────────────────────────────────────────────────────╯

The phrase between ‹ and › is the scope a remembered answer covers. A command offers this exact command, any suggested templates such as cargo check -p <value>, and its token prefixes from the longest to the shortest, such as cargo test -p caudra-agent *, cargo test *, and cargo *. A word that holds a path also offers its folders, such as gh api repos/acme/*. It starts on a suggested template, else on the derived prefix, else on the exact command. A web page starts on this page and below, and a file read on this file. Left broadens the scope and Right narrows it before you answer, and the answers change with it. Blanket grants such as any shell command are offered only in Customize.

A scope that is a template learned from earlier commands adds a muted line under the answers that remember it, such as Learned from 4 similar commands. <value> is caudra-agent or caudra-ui. The count includes the command being asked about. In a batch the line describes the focused command, and it disappears when Left or Right moves the scope off the template.

Warnings appear above the answers as ⚠ lines. They name a protected path, a line Caudra cannot check command by command, the reach of the selected scope, or a decision engine caution such as ⚠ May delete files (88%). A muted line explains an unusual reason for asking, such as Plan mode asks before anything it can't prove read-only. or a line starting with Auto asked:. Details gives the usual reason.

The answers depend on what can be remembered:

RequestAnswers
Most requestsYes, Yes, and allow ‹scope› for this conversation, Yes, and always allow ‹scope› in this project, No, and tell the agent what to do instead
A broad scope while planning, or no project to bind a rule toThe same without the project answer, renumbered
A line Caudra cannot check command by command, such as an inline scriptYes, run it once, No, and tell the agent what to do instead

The No answer opens a one-line field for guidance. Enter sends the guidance to the agent, and an empty field denies without it. Esc leaves the field without answering.

KeyAction
1 to 4Choose that answer
y / s / a / nYes, allow for this conversation, allow in this project, or No with guidance. A letter does nothing when its answer is not offered
Up / Down, k / jMove the highlight
EnterChoose the highlighted answer
Left / RightBroaden or narrow the scope of the focused command
Tab / Shift-TabFocus the next or previous new command of a batch
< / >Broaden or narrow every new command of a batch
eOpen Customize, or the step-through when several commands need an answer
?Open or close Details
PageUp / PageDownScroll a prompt that does not fit
EscDeny from the answers or Details. Elsewhere, go back without answering
Ctrl-CDeny

Answers and footer keys also take mouse clicks. A click counts when the press and the release land on the same answer. An answer needs a key press made after the prompt was drawn, so a held or repeated key cannot answer a prompt you have not seen. Terminals that report key releases rearm on release, and the footer reads Let go of the key, then press it again. while you hold it. Some terminals never report releases. There a key rearms once it has been quiet for a second, and a held key keeps repeating, so it stays blocked. After a press too soon, the footer reads Wait a moment, then press the key again. Pressing a different key rearms at once on any terminal.

Rest the mouse on part of a prompt for half a second and a tooltip explains it. Answers show their letter keys and what they remember. Command rows show their status and the full command when its column cut it. Badges, tabs, Customize fields, inspector controls, and the parts of the Advanced view work the same way. A footer key shows its description when the footer had to drop it. Set tooltips = false under [ui] to turn tooltips off.

For eligible reads, the scope starts on this file or these files. This remembers the resource rather than the full input, so reading the same file with another offset or limit does not need a new grant. Exact-path search grants still constrain the search expression. The exact-call authority continues to require the complete original input. Protected paths, remote requests, plan restrictions, and unavailable persistence can limit the offered scopes and lifetimes.

A filesystem scope is a ladder. Its narrowest rung covers the directories the request touched, and each step up covers the directory above, as far as the filesystem root. Left steps up to the directory above and Right steps back down, so widening changes the reach the answers name rather than adding answers to scroll through. A rung reaching outside the repository adds ⚠ Outside this repository. A rung that takes in your home directory adds a red ⚠ Outside your home directory and needs confirmation.

A URL scope is a ladder too, walked one path segment at a time, so a page can be scoped to the section it sits in. A request for https://example.com/path/to/sub/page starts on this page and below, which covers https://example.com/path/to/sub/page/**. Left widens it through pages under example.com/path/to/sub/ and pages under example.com/path/ to any page on example.com, and Right walks back toward the page. The scheme is shown only when it is not https. A path deeper than eight segments offers its eight deepest prefixes and the origin. A URL with no path offers the origin alone. any public web page reaches other origins, is offered only in Customize, and needs confirmation.

Multiple requests are queued by request ID. A subtask request cannot replace a prompt from the main agent or another subtask. Yes resolves only the selected request.

When policy changes, each pending request rechecks its own current policy and refreshes partial coverage. Separate grants for A and B can cumulatively settle a request needing both. Automatic settlement requires complete coverage under the current deny, ask, lifetime, and workspace restrictions. Policy is checked again before execution, so stale displayed coverage cannot authorize a call. Conversation, project, and global lifetimes limit which waiting requests can share approval.

e opens Customize in place of the answers, with every scope and lifetime the request offers. On a batch, e opens the step-through instead, and Customize opens from its Review page. Esc returns to where Customize was opened without answering.

╭ Allow shell command? · Customize ────────────────────────────────────────────╮
│ │
│ cargo test -p caudra-agent permissions::structured │
│ │
│ Effect [Allow] Deny │
│ Remember Once [This conversation] This project All projects │
│ Scope this exact command │
│ cargo test -p caudra-agent * │
│ ❯ cargo test * │
│ cargo * ⚠ broad │
│ your own pattern… │
│ any command in this folder ⚠ broad │
│ any shell command ⚠ broad │
│ │
│ Tab next field ↑↓ choose Enter apply v advanced Esc back │
╰──────────────────────────────────────────────────────────────────────────────╯
FieldChoices
EffectAllow, or Deny to refuse the request once, for this project, or for all projects
RememberOnce, This conversation, This project, or All projects, limited to the lifetimes the chosen scope allows
ScopeThe ladder from the main view, then your own pattern… and the blanket grants. A suggested template is marked suggested with how often it was seen, and while highlighted it adds a line saying what each slot stands for. A scope that needs confirmation is marked ⚠ broad

Opened from the step-through's Review, Customize lists scopes for the whole line: these commands exactly and the blanket grants. Under Deny it offers this exact script.

While planning, Remember offers This project only for a scope that is not broad, and never All projects. A broad scope adds the line While planning, broad scopes last for this conversation. See Plan mode.

KeyCustomize action
Tab / Shift-TabFocus the next or previous field
Up / DownChoose a scope
Left / RightSwitch the effect while Effect is focused, otherwise change how long
EnterApply, or open the field for your own pattern
iOpen the argument pattern inspector on a template
vShow or hide the full rule the chosen scope would store
?Open Details
EscGo back without answering

Some scopes reach far enough that Caudra asks again before it stores them. Choosing one adds a red line naming what the agent could then do, such as ⚠ The agent could run any shell command without asking. For this conversation, press Enter again to confirm. A project or global rule needs its phrase typed exactly:

PhraseScope
ALLOW BROAD SHELL ACCESSAny shell command, any command in a folder, a whole program such as cargo *, or a pattern of your own graded as a whole program
ALLOW OUTSIDE HOMEA folder that takes in your home directory
ALLOW DIRECTORY CHANGESChanges anywhere below a folder
ALLOW FILE CHANGESChanges to the files of this request
ALLOW ANY URLAny public web page
ALLOW ANY SEARCHAny search query

A whole MCP tool can be allowed for this conversation only, so it needs the second Enter. Scopes that reach protected files, writes outside the project, and widened argument patterns also need the second Enter. When several remembered commands need confirmation, the strongest one applies, and phrases are asked in command order. Esc goes back without answering.

? opens Details over the prompt, and ? again closes it. Esc in Details denies the request. Details lists plain sections, each shown only when it has something to say:

SectionContent
What will runThe full command, or what the tool asks for
WhereThe folder or workspace it applies to
Why Caudra is askingThe reason, and the Auto asked: line when Auto left it to you
Already allowedEach covered command and the rule that covers it
What choices 2 and 3 allowWhat each remembering answer would store, scope by scope
Decision engineEvery caution with its likelihood
ToolThe tool and where it comes from, such as shell (built-in)
InputThe input as the tool receives it, with likely secrets masked

A value that Caudra stores only as a fingerprint reads a fixed value Caudra can't show.

A shell line can run several commands. When it does, the prompt gives each command its own row, in the order the line runs them, and the title counts the new ones:

╭ Allow shell commands? ─────────────────────────────────────────── 3 of 6 new ╮
│ │
│ cargo fmt -p caudra-agent && cargo clippy -p caudra-agent --tests && rm │
│ -rf target/tmp && git push origin HEAD && rg -n TODO src && head │
│ │
│ ▸ new cargo fmt -p caudra-agent ‹cargo fmt *› │
│ new cargo clippy -p caudra-agent --te… ‹cargo clippy *› │
│ new rm -rf target/tmp ‹this exact command› │
│ asks git push origin HEAD git push * · config │
│ allowed rg -n TODO src read-only │
│ allowed head read-only │
│ │
│ ❯ 1. Yes │
│ 2. Yes, and allow these 3 commands for this conversation │
│ 3. Yes, and always allow these 3 commands in this project │
│ 4. No, and tell the agent what to do instead │
│ │
│ Tab next ← broader → narrower <> all e one by one ? details Esc no │
╰──────────────────────────────────────────────────────────────────────────────╯
StatusMeaning
newNeeds an answer. The row shows the scope a remembering answer stores for it
asksAn ask rule covers it, so it asks every time and cannot be remembered. The row names the rule and its source
allowedAlready covered. The row names what covers it, such as read-only, built-in, rg * · project, or this conversation

More than three allowed rows fold into one line, such as + 5 already allowed, and Details lists them.

▸ marks the focused row. Tab and Shift-Tab move between the new rows. Left moves the focused row one step broader and Right one step narrower, and < and > do the same for every new row. A row at the end of its ladder stays put. Each ladder runs narrowest first: this time only, this exact command, suggested templates, then token prefixes from the longest to the shortest, with the path components of a word between the two prefixes it separates. The shortest prefix names the program alone, such as cargo *, and needs confirmation. A row starts on its suggested template, else on its derived prefix, else on the exact command.

Answers 2 and 3 count the rows they remember, as in these 3 commands, or name the scope when only one row is remembered. With every row on this time only, they are left out. Answer 2 remembers each row for this conversation, and answer 3 in this project. The step-through gives each command its own lifetime.

The scope you pick controls what Caudra remembers, never which commands run. this time only runs the command now without remembering it. Shell operators still decide execution order and conditional execution, and the effects of earlier commands stay when a later one fails. Each remembered row becomes its own rule, so /permissions lists the commands separately and revoking one leaves the others in place.

A chosen scope can cover another row. Caudra then stores only the covering rule, as long as it lasts at least as long as the other row. Rules you already have never replace a scope you chose. They change what the rows show and leave authorization to the policy check.

Remembered rows are validated together and stored in one transaction, so a failed write leaves no partial set. An ephemeral session keeps its conversation in a separate database. Its project and global rules are stored first, and a failed conversation write withdraws them before the prompt reopens.

A line Caudra cannot check command by command, such as one running an inline script, keeps its rows and offers only Yes, run it once and No. Shell parsing lists what makes a line uncheckable.

e on a batch opens the step-through at the focused row. It has a page for each new command and a final Review page. The tabs at the top name each command by its executable and subcommand, and a visited page gets ✓.

╭ Allow shell commands? ─────────────────────────────────────────── 3 of 6 new ╮
│ │
│ cargo fmt │ cargo clippy │ rm │ Review │
│ │
│ cargo fmt -p caudra-agent │
│ │
│ 1. This time only │
│ 2. This exact command │
│ ❯ 3. cargo fmt * │
│ 4. cargo * ⚠ broad │
│ 5. Your own pattern… │
│ │
│ Remember for ‹this conversation› │
│ │
│ ↑↓ scope ←→ how long Enter choose Tab next Esc back │
╰──────────────────────────────────────────────────────────────────────────────╯

A page lists the command's whole ladder as numbered answers, with badges such as suggested and ⚠ broad. Your own pattern… opens a field for a pattern of your own. Remember for sets how long this command is remembered: this conversation, this project, or all projects. It offers only the lifetimes the chosen scope allows and is hidden while This time only is chosen. In plan mode it offers this conversation, and this project for a scope that is not broad.

KeyPage action
Up / DownMove the highlight
Enter or a numberChoose that scope and go to the next page
Left / RightChange how long this command is remembered
Tab / Shift-TabGo to the next or previous page without choosing
iOpen the argument pattern inspector on a template
EscDiscard the draft and return to the main view

Review lists every command with its scope and lifetime. Asking and allowed commands say so.

╭ Allow shell commands? ─────────────────────────────────────────── 3 of 6 new ╮
│ │
│ cargo fmt │ cargo clippy │ rm │ Review │
│ │
│ cargo fmt -p caudra-agent cargo fmt * this project │
│ cargo clippy -p caudra-agent … cargo clippy * this conversation │
│ rm -rf target/tmp this time only │
│ git push origin HEAD asks every time git push * · config │
│ rg -n TODO src already allowed read-only │
│ head already allowed read-only │
│ │
│ ❯ 1. Yes, and remember as listed │
│ 2. No, and tell the agent what to do instead │
│ 3. More options for the whole script… │
│ │
│ ↑↓ choose Enter confirm Shift-Tab back Esc main view │
╰──────────────────────────────────────────────────────────────────────────────╯

Yes, and remember as listed (y) stores each command for its own lifetime, and reads Yes, run them once when nothing would be remembered. No (n) asks for guidance as in the main view. More options for the whole script… opens Customize with scopes for the whole line. Shift-Tab returns to the last page, and Esc to the main view.

Only Review applies the draft. A policy change while the step-through is open keeps your choices, unless it withdraws a scope you chose. That row then falls back to its default, and the next answer needs a fresh key press.

A suggested template such as cargo check -p <value> can be inspected and edited before it is stored. Press i on it in Customize or on a step-through page. The inspector shows fixed command words, variable argument positions, working directory, evidence, and whether the current command matches. Patterns match parsed static arguments. They never interpolate captured values into command text.

Use Tab to focus controls, then arrows to select a slot or mode. The mode shortcuts are:

KeyModeCoverage
1ValuesSelected observed literal values
2ExactOne exact literal value
3GlobOne entire argument matched by a glob
4RegexOne entire argument matched by a regular expression
5AnyAny one literal argument. Values that look like options stay refused

e edits a constraint, o shows observed values, and c switches between observed tuples and independent combinations when available. N edits the pattern name and n edits a slot label. Names are display labels and do not change matching or rule identity. The executable, fixed arguments, argument count, and slot positions stay fixed.

A suggested slot is named after the long flag before it, such as <package> after --package. A slot whose observed values all contain / is <path>, and any other is <value>. Repeated names are numbered, as in cp <path1> <path2>. A name is only a hint. The main view, Customize, Discover, and the Rules pane add a line stating what each slot stands for, such as <value> is caudra-agent or caudra-ui. It names at most four values and counts the rest.

For example, cargo check -p <value> can restrict its variable argument to the observed values caudra-agent and caudra-ui. It does not cover another executable, another subcommand, or extra arguments. Option-looking values remain rejected unless the host has proved the position is data. Choosing Any keeps that check.

Slots with an unknown role can include arguments after fixed flags. That position does not prove the argument is data or establish the flag's arity. These values can select program operations, so the inspector and approval review caution against widening them.

Suggestions start with observed literal values and observed tuples, without wildcards. Tuples preserve combinations. If two slots were seen as (alpha, json) and (beta, text), they allow only those pairs. Independent combinations also allow (alpha, text) and (beta, json). Widening one slot to Glob, Regex, or Any still leaves the tuple restriction in force until you explicitly choose independence.

Glob matching is case-sensitive over UTF-8 bytes. ? matches one byte, * excludes a literal /, and ** can cross / in globset's recursive forms. Backslash escapes metacharacters, and braces and character classes use globset syntax. For example, src/*.rs matches src/main.rs but not src/nested/mod.rs, while src/**/*.rs can match both. These patterns match one complete argument without shell or filesystem expansion. The inspector displays these semantics beside the preview.

Regex uses Rust's finite-automata regular-expression engine, with whole-argument matching. Regular constructs such as alternation, groups, and repetition work. PCRE look-around and backreferences do not. Expressions, nesting, compiled size, input, and retained evidence are bounded. Invalid or oversized expressions show a compile error and cannot be used.

p takes a valid pattern back to the page or to Customize without answering, and Esc leaves the inspector without it. A pattern that does not match the current command must be fixed or the command run once instead. Policy rechecks the complete call on approval. Glob, Regex, Any, and independent multi-slot combinations need a second Enter before they are stored. A remembered pattern is explicit execution authority, even for an unfamiliar CLI. It never makes that command read-only or sandboxed.

To remember a token prefix of your own, choose your own pattern… in Customize or Your own pattern… on a step-through page. A prefix must end in a bare * or end its last word in * right after /, =, :, or @, as in gh api repos/acme/*. It must hold at least one literal token before the wildcard, use at most eight tokens, and match the command. The line under the field says whether it matches or names the reason it is refused. Enter accepts a matching pattern and Esc leaves the field. Caudra validates the text without running it.

Two patterns are accepted with a caution:

  • A pattern with one literal covers a whole program, such as python *. It reads ⚠ Any use of this program. and needs the same confirmation as any shell command. Typing a pattern Caudra offers for that command, such as ls *, is graded like the offered scope rather than as a broad grant. A path after the one literal, as in cat /etc/*, drops the caution unless the program can run code, as python3 scripts/* can.
  • A pattern overlapping a builtin always-ask family, such as git push *, reads ⚠ Overlaps commands Caudra always asks about. It is allowed because those are often the commands worth shortcutting, so read it before confirming.

Grading is structural. It checks the shape of the pattern and that it matches the command, and it cannot know what a program does with its arguments. sed -n * grades clean, yet GNU sed can run shell commands through the e escape. Write patterns for programs whose arguments you understand.

Caudra learns permission suggestions from tool use. Suggestions are never automatic grants or the default future scope. Live recognition needs at least three eligible command observations and can propose a pattern within one session. A compound request can supply several observations. Counts do not establish successful execution.

Only calls that are allowed keep teaching. A call refused or cancelled before it runs is withdrawn from live recognition, and a waiting prompt loses any template it supported. Saved conversations mark each call that permissions refused, including each refused command of a batch, and history discovery skips those calls. Conversations saved by earlier versions carry no marks, so their refused calls still count.

Automatic suggestions come only from eligible live observations or imported session history. A command without enough evidence has no suggested argument template. You can also create a template from explicit command text without history. The executable, workdir, and argument structure stay bound, and every template requires explicit approval.

Recognition compares individual commands with fixed argument structure and observed literal values. It can handle unfamiliar CLI names without a read-only executable allowlist. Payload and sensitivity guards still exclude interpreted code, unsafe expressions, and suspicious literals. It does not learn whole command sequences or generate scripts. Basic chains and pipelines are analyzed per command only where control flow and working-directory context can be established.

The local TUI loads bounded historical proposals in the background at startup, for the current tab, and after /cd. Loading is cached per canonical project and cancellable, and stale results are discarded. Remote and ephemeral sessions do not run history discovery. Discover marks imported history as unverified, and the argument pattern inspector also names its unknown outcomes and historical execution context. Analysis assumes standard Bash startup and uses the session's current stored cwd as an approximation. Loading these proposals does not make them verified live evidence.

Open /permissions discover for the Discover tab. The Rules tab contains stored rules and policy. Discover lists only proposals, which are not active permissions. Click either tab or press Ctrl-G to switch. Opening Discover does not force a new scan.

KeyDiscovery action
EnterFocus the selected proposal's pane
Ctrl-ECreate permission from the selected proposal
Ctrl-GSwitch between Rules and Discover
Ctrl-OShow the discovery overview and scan diagnostics
Ctrl-RScan or refresh, bypassing an older cached result. An active scan is not restarted
Ctrl-XCancel the current scan request

The overview reports Not scanned, Loading, Ready, Partial, Unavailable, or Cancelled. Completed scans say in plain sentences how many sessions, rows, and tool calls were read, with sizes such as 24.0 KiB of 4.0 MiB, and how many suggestions were found. Partial lists cutoffs and exclusions, including per-parent row limits, omitted command scopes, and source obligations. Unavailable gives the reason discovery cannot run. Cancellation discards late results for that request and leaves active permissions unchanged. Press Ctrl-R to retry.

Imported proposals need at least two observations from two independent parent sessions. Repeated commands in one session are insufficient. An empty list can also reflect unsupported or sensitive commands, sample limits, or dismissed and snoozed definitions.

Each proposal row leads with its template, such as cargo test -p <value>, and ends with how often it was seen and where, such as 4× · 2 conversations. Proposals from imported history count sessions instead of conversations. The pane beside the list shows the template, what each slot stands for, the commands it covers with their counts, what still asks, and where it was seen. Its last line says the proposal is not active and that Ctrl-E drafts a permission to review. Enter focuses the pane without granting anything, and PageUp / PageDown and the mouse wheel scroll it.

Create permission opens an editable draft. Select the currently registered local shell target and supply concrete command text and an absolute workdir for fresh host analysis. Historical tool identity and context do not authorize the new rule. Configure its input constraints and lifetime, then review and Save as described under Stored rules. A matching live prompt is not required. Opening the draft or analyzing its source grants nothing.

Ctrl-D dismisses the selected definition for the project, and Ctrl-S snoozes it for 24 hours. These preferences persist as bounded project and definition digests and leave active rules unchanged. Renaming a display label does not change the definition's identity.

Use caudra permissions discover for an explicit read-only scan and its limits. Neither background discovery nor the CLI executes historical commands.

Selecting Plan while Build work runs does not change that work. A conflicting submission offers a choice to keep editing, queue in Plan, or stop the work first. See Selecting Plan while work runs.

The plan tool works only on the session's own plan. The main agent can replace it in Plan and Build, and tasks can only read it. Exact-target writes can receive scoped plan approval in either mode, but explicit denies, configured asks, and a default Deny still apply. Reading the plan needs no approval in any mode, local or remote, and a default Deny does not block it. An explicit deny rule still refuses the read, and an explicit ask rule or a forced prompt still asks. A profile can disable the tool.

A plan prompt asks Allow reading the plan? or Allow changing the plan?. It shows the path of a local plan and names a remote plan this session's plan.

While plan mode is active, Caudra withholds the authority that would outlive the plan. Remembered project and global rules do not apply, and allows from permissions.toml do not apply. Deny and ask rules still apply, because they only restrict access.

A conversation grant made while planning does apply for the rest of the plan. Approving broad shell authority for the conversation lets the agent keep exploring with scripts and searches instead of asking about each command. The grant stays with the conversation after you leave plan mode. Yes covers only the current call.

A narrow scope, such as this exact command or git log *, can also be kept for this project. Caudra stores the project rule together with a copy for this conversation, so the grant covers the rest of the plan as well as later Build work, and /permissions lists both. A plan in another conversation still asks, because project rules never apply while planning. A broad scope, such as cargo * or any shell command, lasts this conversation at most, and no grant made while planning lasts for all projects.

With YOLO mode on, plan mode skips these prompts too. YOLO approves each call once and stores no rule. Plan mode still refuses what it always refuses, such as file writes outside the plan.

Reading this project's plans and memory notes never asks, in plan mode or any other mode. The file and code tools may read the plans/ and memories/ directories under …/state/caudra/projects/<project-id>/ (see Directory layout). The allowance covers reads only, and another project's documents still ask. A symlink inside those directories cannot carry a read outside them. Tools in a remote workspace run on another machine, so they get no such allowance.

Viewing, zooming, searching, and reading notes with the memory tool needs no approval either, local or remote. Writing or deleting a note goes through the normal checks.

A read-only agent is a subagent that may not change anything: research tasks, task calls in plan mode, and every agent a workflow starts in read-only capability mode. Only audited host tools with safe call effects are eligible, and the read-only tools of a recognised MCP server. Other MCP and plugin tools are excluded. When an audited shell is available, Caudra judges each command line rather than the tool as a whole.

A line is admitted when the classifier rules every command in it read-only and every path it touches resolves inside the project. git diff, git log, rg, and wc -l pass. Git options that only shape what is printed pass in their = form, such as --format='%h %ci', --date=short, and --since=2.weeks. A format holding %G does not, because signature placeholders run gpg. Anything that writes, anything the parser could not read, and anything reaching outside the project is refused with a message naming the call and the reason, and the agent can retry with a narrower line. The same classifier answers here and in plan mode, so a command plan mode would refuse is refused here too.

The confinement check resolves symlinks before it answers, so a link checked into the repository cannot carry a read out of the project. It says nothing about what an admitted command reads inside the project: a read-only agent can still read any file you have.

A glob that shell parsing can check, such as src/*, is expanded the way Bash does by default before the check: * never crosses / and skips names that start with a dot. Every match must resolve inside the project. A glob counts only where its matches are paths to read: an operand of ls, cat, head, tail, wc, du, file, stat, tree, or sort, an operand after the pattern of grep or rg, or a path after -- in a Git read, so echo src/* is not admitted. Expansion stops after 4096 directory entries or 1024 matches, and a glob past either limit is refused. A remote workspace refuses globs, because Caudra cannot list its files.

A read-only agent's file tools can also read this project's plans and memory notes without asking, as described under Plan mode. A shell line reading them is refused, because they sit outside the project. A task can read the session plan with the plan tool but cannot replace it. An agent a workflow starts while the session is in Plan can read it too. One started in Build gets no plan.

Profiles cannot relax this restriction or grant write access or the main agent's right to replace the plan.

Use /permissions to manage stored conversation, project, and global rules and inspect policy. Builtin, configured, and trusted-plugin policy appears alongside stored rules. Each row reads as a sentence: the effect, the scope, how long it lasts, and who added it. Commands and command patterns in the list and the detail pane are coloured as shell code.

Allow cargo test * this project you
Deny git status --short this conversation you
Ask bash: git push * always config
Allow bash: git log * always built-in

A stored rule lasts for this conversation, this project, or all projects, and policy reads always. other project, inactive, and revoked mark rules that do not apply here. The origin is you, config, plugin, or built-in.

The detail pane summarizes the selected rule in plain words: what it allows or refuses, where, for how long, and who added it. Enter focuses the pane without editing or revoking anything. The full scope, with named inputs, typed targets, context, and authority constraints, appears in Edit. Project-config trust rows open a separate confirmation.

KeyManager action
Ctrl-NNew rule
Ctrl-EEdit the selected stored rule, or Edit source when a verified local source is available
Ctrl-UDuplicate the selected stored rule
Ctrl-YCopy the selected stored rule, leaving its source unchanged
Ctrl-KStart a separate Revoke review
Ctrl-FCycle All, Here, Other, and History filters. History shows revoked records

The toolbar also supports mouse input. Wide terminals show the list and details side by side. Narrow terminals show the focused pane. Tab / Shift-Tab switches focus, and arrows or PageUp / PageDown navigate the focused pane. The mouse wheel scrolls the pane under the pointer.

Edit replaces the stored rule and retires its previous record when saved. Duplicate creates another rule without retiring the source. If a lifetime change crosses separate conversation and persistent databases, use explicit Copy instead of replacement. Copy and a later Revoke are separate reviewed writes, not an atomic move. Copy leaves every source rule active, including deny and ask rules.

The editor has Rule, Targets, Arguments, Template, Changes, Scope, and Test sections. Use Tab or arrows to focus controls and Enter or Space to activate them. Enter while editing a field accepts that field only.

In Rule, choose a registered target, effect, lifetime, and project binding. Capability families are available only where offered by the target. Effects are Allow, Deny, and Ask. Saved lifetimes are Conversation, Project, and Global. Once belongs to a live prompt. Only Project lifetime takes a project binding, either the current project or an explicit absolute path. Workdir and template context are separate constraints. Changing lifetime or project binding does not rewrite them.

Authoring uses the current host catalog, not tool names or arbitrary identity text. The implemented provider supports audited local Workcell registrations, subject to the current tool filter, agent mode, and host availability. Remote, MCP, and plugin tool authority authoring is unavailable. Existing active rules remain inspectable and revocable. Label-only edits preserve their authority. Revoked records are inspection-only.

Targets offers only the selected registration's resource kinds, access types, conditions, and match modes:

ResourceOffered match modes
File or directoryExact path, filesystem subtree, Any
Shell commandExact command, token prefix, command template, Any
URLExact URL, URL origin, URL subtree, Any
Search queryExact query, Any
Environment-inspection custom resourceExact value, Any

Shell targets can have an exact, subtree, or Any workdir condition. Directory targets offer an exact recursion condition. Glob and Regex are command-slot modes, not general resource match modes. A rule matches when any of its targets does, and a target matches when all of its access, protection, and attribute conditions hold. Removing the last target leaves an invalid blank. Unrestricted resources and wildcard conditions require explicit choices.

Arguments constrains the whole tool input independently of targets. Choose exact JSON input, selected JSON pointers, or explicitly unconstrained input. Missing input is distinct from JSON null. Changing a target does not remove an existing input constraint. Supply replacement input or explicitly choose Keep old input pin when retaining that constraint is intended.

A value Caudra stores only as a fingerprint reads a fixed value Caudra can't show, and sanitized review labels do not recover it. Such a constraint stays in force until you choose a replacement mode and enter a value. Label-only changes can keep it unchanged. New rules, copies, and authority expansions require reviewable values. A display label cannot substitute for a missing target or input.

Choose Preview (Ctrl-P), inspect the before/after Changes and resulting Scope, and confirm the listed authority changes when required. Save (Ctrl-S) is a separate action and waits for durable acknowledgment. Background validation never saves. Draft or context changes invalidate the reviewed preview and require fresh review. Saving a grant or relaxing a restriction can release pending requests after policy rechecks.

To create a template without a live request or historical proposal:

  1. Choose New and select the registered local shell target. In Targets, add a Command target and configure its access and protection conditions.
  2. Open Template. Enter a concrete Source for analysis, an absolute Analysis workdir, and a template name. Choose Create template.
  3. The host derives the argument list, roles, and execution context through nonexecuting analysis. The initial template has only fixed literal arguments and no slots.
  4. Select an eligible data or unknown-role argument and use Add/unlink slot to make it variable. Configure the remaining Rule and Arguments fields, then Preview, review, and Save.

Analysis requires one complete, static, reviewable shell command. It checks current binding and eligibility without executing the source. Creating a template does not add historical observations or prove that the command is safe.

Typed slot controls edit labels, allowed values, Exact, Glob, Regex, Any, and tuple or independent combinations. Their matching rules are described in the argument pattern inspector. Manually added values and tuples are constraints, not observed evidence. Link to selected slot requires equal source arguments. Removing a slot requires an explicit fixed replacement for every occurrence. Adding, unlinking, linking, or removing slots requires fresh host analysis before the structural change is applied.

Discover activation and duplicated or copied templates also require fresh source analysis against the current registration. Historical context is not reused as current execution authority. Lifetime remains independent of the template's workdir and project context.

After a valid preview, open Test, enter example JSON input for the registered target, and choose Test, never execute. Analysis uses the current session binding and accepts a workdir in input only when the host supports it. No sample command or tool call is executed.

Matches this rule reports whether the draft covers that example. Effective policy separately reports Allowed by policy, Prompt, or Denied with the draft included. Other rules and execution restrictions can change that outcome. Allowed by policy is not a promise of execution. Dispatch gates are checked again when a real call runs.

Edit source opens a verified local policy file or loaded plugin entrypoint in the local workbench. The host checks its path and loaded content before opening it. This edits local text, even from a remote workspace. Saving a permissions.toml of a local session reloads the policy, but it never grants project-config trust. Changed project allows wait for trust review. Saving a plugin entrypoint changes nothing until /reload.

Verified-source editing currently requires Unix. Saves check the retained file identity and contents and refuse changed sources or symlink substitutions. Existing dirty remote tabs remain separate and are restored when you return.

Builtin policy, remote policy, and entries without a verified local source or supported editing API remain read-only in the manager. A navigable local plugin entrypoint enables text editing, not typed plugin authority authoring. Editing source policy never creates a stored override.

Project and global prompt decisions are stored in the permission.rules row of Caudra's owner-only SQLite state database. Authorization uses SHA-256 digests for exact input and resource constraints. Selected-input authorities use JSON pointers and a digest. Host-derived command patterns are clear-text policy, such as git diff *.

Argument patterns and names-only browse grants use new durable selector or capability tags, and a token prefix that ends inside a path component uses new pattern syntax. Older binaries cannot open permission state containing those grants. There is no backward-compatibility layer. Update every Caudra process sharing the database before using these scopes, including sessions in other projects.

The permission manager also upgrades the database schema to fence delayed session saves. The upgrade requires other database users to close and creates a backup before changing the schema. It preserves existing rules without rebinding their authority. Older binaries cannot reopen the upgraded database.

Separate typed review metadata stores meaningful sanitized paths, command patterns, and recognized first-party input names and values. Likely secrets are redacted, bulk content and unrecognized fields are omitted, and descriptions are bounded. These descriptions can contain private project information even after sanitization. The database is owner-only, not encrypted. Review provenance is approved, recovered, or unavailable. Review metadata never grants authority or relaxes a stored constraint. Displayed omitted fields remain constrained for exact-input rules.

Conversation rules are stored with the session. A persistent write must finish before Caudra executes the approved call. If storage fails, the durable approval fails and the prompt remains open in the TUI.

Older review metadata requires the explicit caudra permissions repair-review command. Its default is a dry run. Applying it repairs descriptions across persistent rules and stored conversations, takes a SQLite backup, and leaves authorization unchanged. Unverified historical values stay unavailable. Use --retry-unavailable to retry unavailable or incomplete recovered reviews while preserving approved reviews and existing verified labels.

Use --database to select an existing canonical absolute caudra.db path, and check the database path in the report before applying. Development binaries default to the separate caudra-debug namespace. The CLI reference shows how to target the production database explicitly.

Ephemeral runs still read and write project and global permission decisions in the persistent state database. Conversation rules stay with the temporary session and disappear with it.

For rules bound to another project or a renamed directory, use the read-only CLI inventory and reviewed rebind. Authorization never follows an old stored project's current symlink to transfer authority. Rebinding is fresh authorization for the destination. Unknown hashes need verified candidates, and unsupported input constraints need fresh grants. Related deny or ask rules can block a transfer and remain active at the source when copied. Project-config trust and YOLO are never transferred.

Use caudra permissions audit for a bounded, read-only summary of logged prompts, decisions, and paired waits. Counts measure events, not unique requests or a prompt rate. Wait summaries exclude duplicate or colliding pairing keys. The CLI reference lists sampling limits and timestamp filtering.

Caudra reads policy from:

  • Global: ~/.config/caudra/permissions.toml
  • Project: .caudra/permissions.toml

TOML supports deny, ask, and allow. Deny and ask rules are active from global and project config. Only validated shell allow patterns can grant authority. Global shell allows are active immediately and bind to Caudra's native Workcell shell contract. Other name-only allows remain inactive review candidates.

Project shell allows require trust before they become active. On startup, the TUI opens /permissions and offers to trust the project policy digest for the canonical project. The digest covers project shell allows and every project deny or ask rule. Editing any of them invalidates trust, and /permissions can revoke trust explicitly. Non-interactive modes leave untrusted project allows inactive. Project deny and ask rules remain active without trust because they only restrict access. Changing projects with /cd reloads the destination policy before further tool calls.

The TUI also reloads both files when they change on disk, before further tool calls. Deny and ask rules apply at once. An edit to the project rules invalidates trust, so project allows stay inactive until you review them in /permissions. A [review permissions] chip in the status bar opens the review. Neither the agent nor a repository can grant access by writing the file. A file that fails to load denies every tool call until it loads again, as at startup, and a red [permissions.toml invalid] chip stays in the status bar meanwhile. See Hot reload.

A checkout of a git repository also accepts trust granted at the same place in a linked worktree or other checkout of that repository, as long as the digest is identical. The grant itself stays with the checkout where you made it. Revoking trust in any checkout revokes it at the same place in all of them. Project MCP servers and project workflows follow the same rule. See Trust across checkouts.

An unreadable or malformed permissions file fails closed. Caudra disables inherited allows and denies tool calls until the file is fixed.

The file starts with version = 2. A file without it counts as version 1, which Caudra upgrades as it reads it. A version newer than this build reads fails closed the same way, so an older Caudra never applies rules it would misread. See Config file versions.

A project prompt default cannot weaken a global deny default, including per-tool and MCP defaults.

/permissions lists inactive entries as needs review and shows trusted config policy. Source-backed policy is separate from stored rules. Use Edit source when a verified local source is available, then reload and review any required trust separately.

default = "prompt"
[shell]
allow = [
"rg *",
"git status *",
"git diff *",
"git log *",
]
ask = [
"*",
"git commit *",
"git push *",
"git reset *",
]
deny = [
"sudo *",
"rm -rf *",
]
[mcp.github]
deny = ["admin_delete"]
FieldTypeDefaultDescription
defaultstringpromptWhat a call that no rule matches does: allow, deny, or prompt. allow acts as prompt and waits in /permissions for review, and a project cannot weaken a global deny
FieldTypeDefaultDescription
allowbool | string[]unsetScopes the tool may use without asking, such as ["git status *"], or true for every call. Only shell allows grant access, and a project shell allow waits until you trust the project policy. Other allows wait in /permissions for review
askbool | string[]unsetScopes that always ask, such as ["git push *"], or true for every call
denybool | string[]unsetScopes the tool may never use, such as ["rm -rf *"], or true for every call. A deny in either file blocks the whole call
defaultstringunsetWhat a call of this tool that no rule matches does: allow, deny, or prompt. Unset follows the top-level default
FieldTypeDefaultDescription
allowbool | string | string[]unsetTools to allow without asking: a list of names, one name, "*" for every tool, or true for every tool. MCP allows wait in /permissions for review
askbool | string | string[]unsetTools that always ask, in the same forms as allow
denybool | string | string[]unsetTools the model may never call, in the same forms as allow. false in any of the three adds nothing
defaultstringunsetWhat a call to a tool of this server that no rule matches does: allow, deny, or prompt. Unset follows the top-level default

caudra config example permissions prints every permissions.toml key with its default, all commented out. Reference configs shows the same text.

Shell allow and ask patterns use literal tokens followed by an optional bare * token. The wildcard matches zero or more complete arguments. It must be separated by a space, so git status * is valid and git status* is rejected. The last literal token may instead end in * right after /, =, :, or @, which leaves the rest of that one argument open as a path component does. gh api repos/acme/* matches gh api repos/acme/tool with nothing after it, and gh api repos/acme/* * also allows more arguments. allow = true is the all-command * pattern for native shell tools. Patterns contain at most eight tokens and 256 bytes. Literal tokens may contain ASCII letters, digits, ., _, /, @, :, =, +, and -.

Token prefix patterns do not authorize redirects to ordinary files or heredocs. These produce a protected request carrying the complete original command. Literal /dev/null redirects and file descriptor duplication such as 2>&1 can remain reviewable when their effects are understood. Argument patterns exclude all redirects. Path-qualified executables remain path-qualified, so git status * does not authorize /tmp/git status.

No configured allow reaches a protected command, whatever its pattern. A protected command that no deny names is left uncovered and prompts, so the reviewed text reaches you rather than a rule written against a shape it does not have.

Restrictive rules are also matched against the resolved executable name, so /bin/rm -rf build cannot dodge a rm * deny. Allows are matched against the reviewed text alone.

For shell allow and ask rules, the most specific matching pattern wins and ask wins a tie. Any matching deny still blocks the complete call. Rule order in the file has no effect. A catch-all ask = ["*"] can therefore coexist with more specific read-only allows.

Caudra also asks by default for these command families unless a configured or remembered allow covers them: rm, destructive Git operations, chmod, chown, dd, mkfs, network transfer and remote-login commands, and process termination commands.

Caudra allows echo by default when every argument is literal after quoting, so the reviewed text is exactly what the shell runs. Parameter expansion, command substitution, globs, tildes, braces, redirects, and operators all fall back to the normal prompt, and a configured ask or deny still overrides the default. Single quotes keep their contents literal, so echo '$HOME' is allowed while echo $HOME asks.

A configured scope matches glob-like, whatever its effect:

PatternMatches
* or **Any scope
prefix*Values starting with the prefix
cmd *Bare cmd or cmd followed by arguments
cmd dir/*cmd with one argument under dir/, for a shell scope
cmd dir/* *The same argument, followed by any arguments
dir/**The directory and descendants, using path components
OtherExact text

New remembered decisions use structured matching. Prefix authorities use the strict token grammar above. Argument patterns use the separate inspector constraints and are not TOML shell patterns.

Configured filesystem exact and subtree scopes expand only a leading ~ or ~/ on the rule side. Relative paths resolve against the explicit permission project base, then normalize with existing symlinks. Embedded ~ and ~user stay literal. Generic raw-prefix scopes such as prefix* keep their text-prefix semantics. Tool arguments and shell text are unchanged. If a required home directory or path cannot be resolved, policy fails closed.

Structured requests distinguish files, directories, URLs, commands, queries, and custom resources.

  • File matching uses normalized path components and resolves existing symlinks.
  • Protected paths such as .git, .ssh, .aws, and dotenv files require exact authority.
  • Access outside the project prompts even when ordinary project reads and writes are trusted, apart from the scratch directory.
  • URL matching and fetching reject credentials and ambiguous encoded path separators or dot segments.
  • Shell authority includes the initial working directory.
  • A deny that intersects any resource blocks the complete call.

File-write tools remain pre-allowed inside the project working directory and anywhere under the scratch root, which holds the directory TMPDIR points at. Approval covers the root rather than one project's subdirectory inside it, so /cd cannot strand a path the model was already given. Paths beside the root under the shared temp root still prompt. Read-only filesystem tools declare scopes and trusted native policy allows them by default. Loading a skill is allowed by default wherever the skill lives. A skill name is a catalog key rather than a path, so the tool can only open a SKILL.md under Caudra's own skill directories or read a skill built into the binary. Explicit deny rules can therefore block file_read, file_glob, file_grep, file_index, skill, or image access without adding normal prompt noise.

Every registered model tool reaches the permission manager. A tool without declared scopes receives its canonical validated input as an exact fallback scope. The batch container routes inner calls through the same manager. The code tool routes each call its snippet makes through it too: MCP tools, resource reads, and session history.

Names-only browsing has its own FilesystemBrowse authority:

Tool requestAccess
file_read on a directoryList, direct entries in that directory
file_globRecursive filename enumeration under its root
file_read on a fileFile content read, outside the browse family
file_grep, file_index, source-code toolsContent search or analysis, outside the browse family

List names in this directory covers only the exact directory's direct entries. Browse names below this directory explicitly permits recursive filename enumeration, including file_glob with other filename patterns. It also covers directory listings below the approved root. Neither choice permits reading file contents, content search, writes, or shell execution. Protected paths and symlink boundaries remain checked.

Directory file_read requests bind the canonical target and directory kind during preparation. Execution uses the prepared directory-listing operation and refuses a later file/directory kind change. A listing approval cannot become a content read through that race.

The broader These directories and descendants option uses FilesystemRead, covering reading, listing, and searching across the trusted native read family. It requires explicit selection and excludes writes and shell execution. Choosing Project binds it to the current project even if the directory lies outside it. A sibling checkout does not receive a directory grant by default.

The model calls MCP tools from Python inside the code tool. Starting a run does not ask. Each server call the snippet makes is reviewed on its own, under the rules below, by its server.tool name, such as github.list_issues. A call you decline raises PermissionError in the snippet, which can catch it and carry on. A deny rule for code itself blocks every run.

Reading a resource with read_resource asks too, scoped to the server and the resource's URI. It is allowed in plan mode and in read-only agents, and the prompt offers to always allow reads from that server. Listing a server's resources never asks.

Generic MCP tools use the complete canonical JSON input as their exact authority.

Caudra binds approval to one immutable MCP transport, server configuration digest, remote tool name, and discovered tool contract. A reconnect cannot switch the transport after approval. A changed description or schema creates a different contract.

Generic field names such as path or command do not create reusable resource authority. External servers control their schemas, so Caudra treats these values as display information unless the host has a trusted typed profile.

In Customize, the TUI can allow a whole MCP tool with any arguments for the current conversation. It needs a second Enter and cannot be stored for a project or globally. ACP and SDK clients remain exact-only.

A recognised server gets more care, and its read-only tools get the treatment of Caudra's own read tools:

  • Read-only tools. A tool the server marks read-only is low risk, works in plan mode and in read-only agents, and still asks in Ask mode. Its prompt offers <tool> with any arguments, which you can keep for the conversation, the project, or all projects without a second Enter. The prompt marks the tool read-only, as the server describes it.
  • Home Assistant devices. A call whose domain names lock, alarm_control_panel, cover, or valve always asks, at critical risk. No rule covers it, Auto leaves it to you, and autopilot never allows it. The prompt says which devices, such as Home Assistant lock devices always ask.
  • Executor approvals. An Executor resume call that accepts a paused run always asks in the same way. The prompt shows what the run is waiting for, such as Executor run waiting for: Deploy to prod? · deploy.run({"env":"prod"}). A run Caudra did not see pause shows as Executor run <id>: not a run Caudra saw pause. Caudra remembers the last 64 paused runs of each server.

YOLO mode runs these calls without asking, as it runs every forced prompt. Recognition uses the name a server reports. A server that reports one of these names gains only its read-only tools in plan mode, and they still ask. Any other server's tools stay blocked in plan mode and in read-only agents, whatever annotations they carry.

A snippet in the code tool can search and read stored conversations through its history module. Each call asks as the code tool to read a session_history resource, named by its project: the main checkout of a local project, the project of a remote workspace, or * for scope="all".

  • The current project. A built-in rule allows reading the history of the session's own project: its main checkout and verified linked worktrees, or its remote workspace. It follows /cd. Only the history module marks a read as the current project's, and the rule allows nothing else.
  • Other projects. A search, listing, or read() that reaches another project, or every project, asks. The prompt offers to always allow reads history of <project>, or reads history of all projects, so later reads of that history do not ask.
  • Broad grants. An allow for code with any arguments covers running snippets and never covers another project's history.
  • Modes. History calls only read, so they are allowed in plan mode and in read-only agents. Where nobody can answer a prompt, such as an unattended headless run, a read of another project is denied unless a rule allows it.

History results are not redacted, so a tool output that once printed a secret can come back in a search. Keep that in mind before you allow all projects.

Bash analysis starts from the normalized initial working directory and tracks the possible directory at each command. Basic &&, ||, ;, and pipeline expressions can receive per-command scopes when control flow and context are proven. Reusable argument patterns require one known effective workdir. Unknown or ambiguous context falls back to manual exact-call review instead of assuming a directory or learning a sequence template.

The parser preserves executable directory prefixes for allow matching. /usr/bin/git status --short therefore does not inherit git status * authority. Deny and ask rules also check the normalized executable name, so rm * still restricts /bin/rm. Quotes keep argument boundaries, and a wildcard consumes complete arguments, or the rest of one argument after a path component, rather than arbitrary text.

A shell prompt can offer a token prefix derived from the reviewed command. A curated table names the families whose first operand is data rather than a subcommand, so rg needle src/ offers rg * and keeps the search term out of the rule. The table also names the families whose subcommand sits behind a namespace token, so npm run build offers npm run build *. Outside the table the leading lowercase words become the prefix, so git commit -m "message" offers git commit *. This prefix heuristic is separate from generic argument-pattern recognition.

A derived prefix never reaches past a flag, so docker -H tcp://host run nginx offers no prefix. A prefix taken from outside the table must name more than the executable and must leave at least one operand behind, which is why git status offers no prefix. Caudra also avoids deriving prefixes that overlap a default ask family, because storing git checkout main * would silence the git checkout * ask.

A command's ladder also offers its other token prefixes, from the longest to the shortest, though a row never starts on one. Unlike the derived prefix, they can include flags. A flag keeps its value when the value is not a flag and holds no / or ., so rustfmt --edition 2024 --check f.rs offers rustfmt --edition 2024 --check *, rustfmt --edition 2024 *, and rustfmt *, and starts on the exact command. The shortest prefix names the program alone and is broad. It needs confirmation and lasts this conversation at most while planning. It is never offered for shells, interpreters, wrappers, or privileged and indirect commands such as bash, python3, env, sudo, and eval, because any use of those can run any code. Prefixes that overlap a default ask family are left out, so git log -1 offers git log -1 * and git log * but not git *.

Some lines cannot be checked command by command. Caudra then reviews the whole line as one protected request, names the cause in a ⚠ line, and offers only Yes, run it once and No:

CauseExamplesWarningAuto
Loops and conditionsfor, while, if, case, functionsUses loops or conditions that rules can't checkScreened
File redirects> out.txt, or data in a heredoc such as cat <<'EOF'Redirects input or output in ways rules can't checkScreened
Words built at run time$(…), <(…), $((…)), $HOME, assignments, declarations such as export A=1, cd to a computed path, globs such as *.rs or ~/x*, unset PATH, set options other than the inert onesBuilds part of the command only when it runsScreened
Wrappersenv, time, xargs, command, builtin, coproc, bash script.shRuns a command through another programScreened
Inline scriptsA heredoc or here-string fed to an interpreter, python3 -c, node -e, bash -cRuns inline Python that Caudra can't check, naming the languageScreened
Indirect codeeval, source, .Runs code through eval or sourceAlways asks
Privilegesudo, su, doasRuns with elevated privilegesAlways asks
UnreadableSyntax errors, an executable that is not literal, a subscript or computed name in unset or a declaration such as unset 'a[$i]', other unsupported syntaxCaudra couldn't read this command lineAlways asks

The most severe cause names the line, so eval in a loop always asks. A redirect to /dev/null or between descriptors, such as 2>&1, keeps a line checkable. Caudra looks inside loops, conditions, and substitutions for the commands they run. It also parses literal shell code given to bash -c or fed to a shell on standard input, up to two shells deep. Code that is not literal, or nested deeper, is unreadable. Auto mode describes screening.

A glob stays checkable when it starts with a letter, digit, ., _, /, +, @, :, ,, or =, and holds nothing but those characters, -, the wildcards * and ?, and bracket classes such as [0-9]. ls src/* then gets a row and a ladder like any other command, a rule for ls * covers it, and deny and ask rules see it too. Any other glob is built at run time. A leading wildcard could expand to a name that reads as a flag, so write ./*.rs rather than *.rs.

Interpreted payloads and sensitivity guards also prevent argument-pattern suggestions. Successful parsing alone does not establish reusable authority.

Configured allows, scope allows, and command patterns never cover a protected command. The two unrestricted shell authorities do, because they already authorize any command the user can write, including tee and an interpreter reading a script from standard input. Selecting one needs confirmation. Deny rules still apply. Builtin command-family asks do not reach protected commands, so a broad grant also silences those asks for them.

Routine probes count as read-only, so they do not ask. A name lookup qualifies when every name is literal, as in command -v rg, type -t cargo, or which jq. A version check qualifies when its only argument is one of these:

ExecutablesVersion argument
python--version, -V
node, npm, pnpm, yarn, perl--version, -v
cargo, rustc, rustup--version, -V
java-version, --version
goversion
deno, bun, ruby, gcc, clang, make, cmake, git, just, rg, jq, uv, pip, pip3, nix, docker--version

Versioned names such as python3.12 count as their interpreter. python -v starts a verbose interpreter and ruby -v reads a program from standard input, so neither is listed. A path-qualified executable such as /usr/bin/python3 --version still asks.

Clearing a variable or setting an error option also counts as read-only, so unset FOO; set -euo pipefail; cargo test gets one row, for cargo test. unset qualifies when every operand is a plain name and none is a variable Bash itself reads: PATH, HOME, CDPATH, PWD, OLDPWD, IFS, ENV, or BASH_ENV. Without PATH, for example, Bash looks commands up in the working directory, so unset PATH; make runs ./make. set qualifies when it only turns -e, -u, -x, pipefail, errexit, nounset, or xtrace on or off. Configured ask and deny rules for unset and set still apply.

Declarations that set or mark a variable, such as export A=1, export A, declare -x A, readonly A, and local x=1, build the command at run time, because any variable can change what a later program does, as GIT_SSH_COMMAND and LD_PRELOAD do. Bash evaluates a subscript such as a[$(id)] as arithmetic, so a name that is not plain makes the line unreadable. Forms that only print variables, such as bare set, export -p, and declare -p HOME, get a row like printenv, because their output can show credentials.

Caudra executes the reviewed command text unchanged. Workcell may reduce completed shell output before the model receives it. The TUI shows raw output while the command runs, then switches to a labelled filtered view that the user can toggle back to raw.

On Unix, Workcell launches a host-bound absolute Bash executable with --noprofile --norc -c. It does not implicitly load login files or shell startup hooks. The existing environment allowlist still forwards PATH, proxy settings, and selected basic variables. This startup contract does not isolate the commands or their own configuration. See Shell host configuration for executable selection.

The initial working directory is context, not confinement. An approved shell command can still access files, the network, and inherited environment variables.

The builtin read-only classifier is conservative about mutation flags, executable paths, expansions, and named file operands. For example, git branch -D, tag creation, and reflog expiration do not receive read-only authority. A path-qualified executable such as ./cat does not inherit the builtin reader allowance, and an explicitly named protected operand such as .env requires review. These checks do not guarantee containment of recursive reads, program configuration, or repository code. Build and test commands are not read-only exemptions.

execution_environment, which a snippet calls as host.environment(), still requires explicit approval under normal prompting policy. Its fixed probes can invoke sudo policy hooks or refresh credentials. A remembered exact grant can avoid repeated prompts without treating the tool as a pure read. Plan mode asks before running it as well, and Plan mode describes which grants apply there.

Between two token prefixes, a ladder also cuts the word they differ by wherever a path component ends. It cuts after /, =, :, or @, where Ctrl+W also stops in the composer. A dot, a dash, or an underscore never cuts a word, so file.tar.gz and kebab-case stay whole. Each cut is offered twice. gh api repos/acme/* allows one word under repos/acme/ with nothing after it, and gh api repos/acme/* * also allows any arguments after that word. gh api repos/acme/tool/issues climbs like this:

this exact command
gh api repos/acme/tool/*
gh api repos/acme/tool/* *
gh api repos/acme/*
gh api repos/acme/* *
gh api repos/*
gh api repos/* *
gh api *
gh *

Cuts never change where the row starts. A word followed by more words offers only the rungs ending in *, so docker -H tcp://host run nginx offers docker -H tcp://* *. A flag value is cut too, so gh pr list --repo=acme/tool offers gh pr list --repo=acme/* and gh pr list --repo=*, and still starts on gh pr list *. A word offers at most its eight deepest cuts.

The open part of the word must reach the command exactly as written. It cannot hold a blank, a .. component, or anything the shell would expand or read as an operator, so gh api repos/acme/* covers neither gh api repos/acme/../other nor gh api repos/acme/$(id). Quoting is fine, so gh api 'repos/acme/tool?state=open' is covered. Shells, interpreters, wrappers, and privileged and indirect commands get no cuts, because the start of their word can be the start of the code they run. Cuts that overlap a default ask family are left out, as prefixes are. Older binaries cannot open permission state that remembers a cut, as Storage and recovery describes.

Plugin rules apply only while Lua plugins run, which needs experimental.lua_plugins. See Experimental features.

Bundled plugins can declare trusted host policy for resources they own. Builtin allows apply only to implementations marked as bundled by the loader. User plugins do not inherit native or bundled trust. Global user plugins need a valid plugin.toml before they can register allow policy. Project plugins can register deny rules only. Remembered Lua decisions bind to the plugin name, tool name, entry source, required Lua modules, description, and schema. A reload during review cannot switch the approved handler generation.

Lua plugin API capabilities remain separate. plugin.toml controls whether plugin code may call filesystem, network, process, and environment APIs. Tool-call permissions control whether the agent may invoke a registered tool.

Auto mode belongs to the decision engine, which screens what deterministic checks cannot. Screening runs only while a decision endpoint is active.

/auto toggles between Ask and Auto. --auto selects Auto at startup. The status bar shows [auto], or [a] in a narrow terminal. Clicking the chip returns to Ask. --auto and --yolo are mutually exclusive.

Auto skips prompts only when no rule covers the call and the tool's default is Prompt. Configured asks, builtin asks, protected paths, and forced prompts still require approval. In plan mode, shell calls that deterministic checks cannot prove read-only still prompt. Deny rules and default Deny remain effective.

A shell line that cannot be checked command by command, such as an inline script, needs more. Auto runs it only when a decision engine with auto_screening = "enforce" has read the whole line and flagged nothing, and policy did not change meanwhile. Indirect code, privilege, and unreadable lines always ask.

When Auto leaves a call to you, a muted line in the prompt says why:

LineReason
Auto asked: scripts need a decision engine to screen themThe line needs screening and auto_screening is off
Auto asked: the decision engine only advises, so it can't approve scriptsThe line needs screening and auto_screening is shadow
Auto asked: the decision engine flagged thisEnforced screening flagged the call
Auto asked: the decision engine couldn't check thisThe engine failed or timed out
Auto asked: this project turned off decision engine screeningProject configuration disabled globally required screening
Auto asked: sudo, su, and doas always need your approvalThe line runs with elevated privileges
Auto asked: eval and source always need your approvalThe line runs indirect code
Auto asked: Caudra couldn't read this command lineThe line could not be parsed
Auto asked: protected files and commands always need your approvalThe call touches a protected path or command
Auto asked: a rule says to ask firstA configured or builtin ask rule matched
Auto asked: plan mode needs your approvalPlan mode withholds Auto
Auto asked: this tool always asks for approvalThe tool or call forces a prompt
Auto asked: Auto only decides for tools that prompt by defaultThe tool's default is not Prompt

An explicit mode choice is saved with the root conversation. A command-line mode overrides the restored choice. Global always_auto = true supplies the default when neither exists. Global YOLO settings take precedence if both defaults are enabled. Projects cannot set always_auto or always_yolo.

Auto works without an active decision endpoint. Calls that deterministic checks clear still run, and a line that needs screening prompts. With enforced engine screening, a flagged call, engine error, or timeout takes the ordinary prompt path. Without a channel for answering that prompt, the call is denied. Disabling globally required screening in project configuration also restores prompting for eligible calls.

Auto is not a security boundary. An engine miss can let an eligible call run. Engine predictions never grant read-only access or weaken deterministic permission rules.

The decision engine sends its requests to the active decision endpoint, a [decisions.<name>] table in the global providers.toml. Add one with /login or caudra auth login --decision, which offer TypeSafe Jev, OpenAI Luna, and a custom endpoint. Switch with /decisions model, /decisions next, or caudra decisions use <name|off>. With no active endpoint, [decisions] settings have no effect, and existing decision logs stay untouched. An active endpoint enables nothing by itself either. Each feature still needs a mode, and Auto still has to be selected. See Decision endpoints for the fields, the presets, and how keys are found.

Decision features are opt-in and configured in the [decisions] table of the global caudra.toml. A project may disable a feature or logging and shorten retention, but cannot change thresholds or enable a feature. Projects cannot add or select an endpoint, because endpoints live only in the global providers.toml. See the configuration reference for fields, defaults, and supported modes.

Configuring an endpoint, by hand or through login, is the consent to send decision context to it. HTTPS needs no other opt-in, and neither does plain HTTP to numeric loopback. Plain HTTP to any other host needs allow_http = true on the endpoint. Use it only when you control the transport protection, such as an encrypted tunnel. Private and CGNAT addresses do not prove that a tunnel exists. Workcell transport rules remain unchanged. Both protocols send text only.

Decision requests do not follow HTTP redirects. A request to a numeric loopback endpoint always connects directly. Other endpoints use the network proxy, which a project .env cannot set.

With an endpoint active, this caudra.toml evaluates permission advice and Auto screening without changing any prompt:

[decisions]
timeout_ms = 800
log = false
[decisions.features]
permission_advice = "shadow"
auto_screening = "shadow"

Every feature defaults to off. permission_advice = "shadow" evaluates predictions without changing a prompt. Retaining them requires log = true. "advise" can add warnings to an already visible prompt without delaying the user's answer. auto_screening = "shadow" leaves Auto's deterministic baseline unchanged. "enforce" can turn an eligible Auto call into a prompt, and only "enforce" lets Auto run a line that cannot be checked command by command.

A refused answer fails the whole evaluation. Caudra does not apply partial answers, and enforced Auto screening follows the ordinary prompt path on failure.

Each warning is a ⚠ line above the answers, with the predicted likelihood, such as ⚠ May delete files (88%). The warnings are May delete files, May upload or send data, May read or use credentials, May change file permissions, May rewrite remote history, and May change project files. ACP permission requests carry the same phrases. They are uncertain predictions, not proof that a call is safe or unsafe. A model's read-only prediction never grants permission.

shell_effect = "advise" can warn about possible project writes during Plan review when thresholds.shell_writes is explicitly configured. This is caution only. Deterministic checks still decide read-only access. Shadow labels use the deterministic classifier, not observed filesystem changes.

content_screening reads web, MCP, and code results in full, including the part a long result's preview leaves out, in overlapping chunks of about 1.4 KB. A chunk is flagged when both its injection and its agent-addressed signals reach their thresholds.

  • "advise" adds caution to a flagged result and marks the session for tighter upload and credential screening in Auto. This also works in YOLO, with tighter permission screening taking effect if you later switch to Auto. The model still reads the content.
  • "enforce" withholds a flagged result from the model. The model reads a notice instead, naming the flagged chunks, both signals as percentages, and the thresholds, and asking it to tell you rather than fetch the page again. Caudra deletes the saved copy, so tool_output cannot read it back, and marks the session as "advise" does. The card keeps the result for you, with Decision engine: withheld from the model on its header.

"enforce" fails closed. A result is also withheld when part of it goes unscreened: the engine fails or times out, no engine slot comes free within 30 seconds, screening runs past its 2-minute limit, screening is interrupted, or the result is over 64 KiB or has more than 64 chunks. Such a result tightens the session as a flagged one does. Its chip names the cause, such as ◆ screening timed out, ◆ engine unreachable, ◆ screening busy, or ◆ screening incomplete, and only a real detection reads ◆ flagged. Under Session, /decisions shows the two apart: Content says flagged, screening incomplete, or both, and Restrictions says whether the session is tightened. A later clean result never loosens it.

Each screened result costs one engine request per chunk. One engine runs at most four content screening requests at once, shared by every result and session in the Caudra process, so a batch of fetches queues instead of timing out together. While a result waits for a slot, its chip reads ◆ waiting to screen…. A chunk whose request timed out or found the engine unreachable is asked once more, on the same text, after that first request is over, and the chip reads ◆ retrying screening… meanwhile. Caudra never fetches the page again for this. A long page can take several seconds. Predictions can still miss an attack, so treat this as a filter, not an injection barrier.

The optional question-tool nudge can remind the main-session assistant to use question when its attempted final reply asks you for a choice, clarification, or approval. It is separate from permission checks and defaults to off.

The reranking features order or annotate memory notes, retained tool output, truncated output, and code-context rows by their relevance to the current work. They never grant permission, load a tool, or run anything. Each defaults to off.

When a decision feature changes what happens, the transcript says so in a line that names the feature by its configuration key and says what it did, such as source_code_context · kept 12 of 64 rows; left out 52 judged unrelated or goal_prescreen · skipped the goal check. Each line holds names, positions, and scores only, never the state or the candidate text sent to the engine, and any command text in it is redacted. Subagents' decisions appear in their own transcripts.

A decision about a tool call goes on that call's card. While the engine works, the card's header shows a chip such as ◆ reranking…, and once it answers, the chip says what it did, such as ◆ reranked. A chip that warns, such as ◆ asked you from Auto screening, ◆ may write from shell-effect checks, ◆ flagged from content screening, or any chip for a failed call, is drawn in the warning colour, so it stands out on a folded card. Two chips on one card are joined with ·, and three or more become one chip such as ◆ 3 decisions. Click the chips to see each decision's line under the card's header, with every candidate or value, its score, and what became of it, and click them again to fold it. Opening the card alone leaves them folded. A decision about a call in a batch shows its chip on the call's row, and clicking that chip shows its line under the row, whether or not the call is open. When the call's card is not in the transcript, the decision gets a row of its own instead.

A decision about a turn, such as a memory recall, a skill suggestion, or a compaction, is a chip at the right edge of the row that started it: your message, the todo card that started a step, a goal check, or a compaction notice. Click the chip to see what it was based on.

A feature in shadow mode shows its decision marked shadow with what it would have done, and changes nothing. When an enabled feature's call fails or times out, a warning says the default applied. It appears once per feature, until the engine answers that feature again, so an engine that stays down does not fill the transcript. Cancelled calls, calls made stale by a mode or configuration change, and answers that changed nothing show no decision, and a waiting chip on their card goes away. Permission advice stays in the permission prompt, and workflow decide() and rerank() calls show in the workflow inspector.

Decisions are saved with the session and return to their cards and rows when you reopen it. They are display only: the model never sees them, and they are separate from the opt-in decision log that /decisions reads. Set ui.show_decisions = false to hide them. Cards drop their chips and decision lines as soon as you save the file, and new decisions are not shown. Earlier rows stay until you reload. Turning the setting back on brings back the chips of cards already in the transcript at once. The decisions are still saved, so running /reload also shows the decisions made while it was off.

Set log = true to retain bounded, redacted decision states and answers in decision-log tables in caudra.db. A state over the bound is never sent. Its row records a rejected error and the state's size in place of the state. Redaction is best effort both before transmission and before storage. It is not a guarantee that sensitive text has been removed. Human permission answers can supply training labels, but approval is not proof that a predicted effect occurred. Effect fields are a partial action record. A value of none does not prove that no advice or routing was applied. Tool-search records do not have actual-use labels, and shell-effect records do not have observed-filesystem labels.

/decisions opens an inspector with four tabs. Overview shows the active endpoint with its protocol, model, and key source, its cached health, the session's permission mode and taint, logging, and thresholds. Features lists each feature with its mode, allowed modes, and thresholds. Click one of a feature's modes to switch to it, or press Space or Enter to move to its next allowed mode, such as off, shadow, then enforce. The mode under the pointer is highlighted. Caudra saves the mode under [decisions.features] in the global caudra.toml, keeping the file's comments, and every open session uses it at once. A project caudra.toml that turns the feature off still wins, and the footer says so. Activity counts logged decisions per feature, and Recent lists the newest logged decisions with their state, questions, answers, and label. Answers are drawn as a bar for each option, with the likeliest one highlighted. Press j to see them as the logged JSON instead. Press g to switch Activity and Recent between this session, this project, and every logged row. Both tabs read the decision log in caudra.db. Recording new rows requires log = true. The inspector reads the log when it opens and on Ctrl+R. It does not contact the endpoint. While an endpoint is active, the status bar's messages row shows [decisions: <name>], styled as offline when the last request could not reach it. It is the first chip there to fold into [+N] when the row runs short. Click the chip to open the inspector.

Use caudra decisions to inspect configuration and manage the log. list and use show and switch endpoints, and status includes the active endpoint and its protocol without contacting it. purge --yes deletes decision records and labels from the live tables without deleting sessions, messages, or the shell runs behind shell ETAs. This is not secure erasure. SQLite free pages, WAL files, and backups can retain copies. Review exports before sharing them. Only decisions/permission.json in the global configuration directory currently supports a question-file override. See question overrides.

/yolo and --yolo skip prompts after deny rules and hard restrictions have run. The status bar shows [yolo] while enabled, or [!] when the terminal is too narrow to spell it. The warning is the last chip its row gives up, so a narrow terminal drops the reasoning level before it. Clicking it turns YOLO off and brings prompts back, from a task footer as well as the main one.

An explicit /yolo choice is stored with the root conversation. A user-created fork and /new start without that explicit state. --yolo selects YOLO at startup.

YOLO approves each call once and stores no rule, so turning it off brings back the prompts your rules do not cover. In plan mode it also skips the prompts for commands plan mode cannot prove read-only, for send_message and publish_message, and for execution_environment. Plan mode still refuses what it always refuses, such as file writes outside the plan.

YOLO bypasses decision-engine permission advice, Auto screening, and permission-related shell-effect checks, including in plan mode. Shell duration, content screening, tool search, skill selection, goal prescreening, subagent routing, the question-tool nudge, and the reranking features still follow their feature settings. An unreachable engine can still show its chip as offline. Deterministic denies and hard capability restrictions still apply.

While autopilot is engaged, a delegate model decides the prompts that reach you, in Ask, Auto, and plan mode. Your rules and Auto screening run first, unchanged, and YOLO leaves nothing to decide.

The delegate may allow a call once, deny it with guidance, or leave it to you. It never stores a rule. It never allows prompts from plan mode, forced prompts, protected paths, privilege, indirect code, or lines Caudra cannot read, and it allows nothing while content screening has tightened the session. A prompt from an ask rule is not reserved, so the delegate may allow that call once. Any key or click on a card makes it yours. See Permission prompts for the full table.

Website privacy and analytics