Files
qbit-assistant/docs/actions-and-mcp.md
T
james.maesandClaude Fable 5.2 47d3e34f8c docs(process): the design of one confirmation for a set; the card's records and what they were, in the API
docs/one-card-for-a-set.md is the design and the safety argument for parts A
to D; README, UPGRADE, CHANGELOG and the agent notes follow it. UI API
extension assistant 1.11.0 (additive): AssistantActionV1.recordCount,
records and recordsBefore for a run over a set.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-15 05:28:55 -06:00

97 KiB

Actions and MCP: the assistant does what the signed-in person may do (design)

Status: approved by the owner on 2026-11-12, with the decisions recorded in section 11.1. Nothing in this document is built yet unless a section says "today" or is listed under "Built so far" below.

Built so far in this repository (each entry says where the code differs from the text; the code wins):

  • A1, the tool registry and the tool-call service (tools/registry, engine/ToolCallService).

  • A3, pending actions with before and after values, kinds, the list and retention.

  • A2, data access defaults in code (sections 2.4, 3.1 and 3.2). Differences from the text:

    • The administrator's row narrows what the code says and never raises it, a code default included. A host that sets withDefaultTableAccess(READ) opens single tables with withTableAccess(table, READ_WRITE) in code; a READ_WRITE row does not (3.1 lists the code default last, which could be read otherwise).
    • The write tools are offered to a person who may create, edit or delete records of some table themselves, asked of the UI API as that person, and not merely when some table's data access allows writes (3.1 says "whenever the person can see at least one table that is not READ or NONE"). UiApiToolbox.anyWritableTable() is gone; UiApiToolFamily.writableTables answers per person.
    • The migration's "never edited" test is modify_date < create_date + 1 second, not create_date = modify_date (3.2): core sets a row's two dates in the same insert from two readings of the clock, a few microseconds apart, so the equality would match almost no row.
    • The assistant's own tables and processes are NONE by a pin in code that nothing can raise (DataAccessService.isOwnTable), in addition to core's channel wall.
    • When the administrator's rows cannot be read and none were ever read, every table is NONE (the text does not say; before A2 the fallback was the old default, READ).
    • The assistant refuses to answer anybody for whom no spending limit is in force (owner decision of 2026-11-12, not in this document): BudgetService.limitInForce.
  • One confirmation for a set, no card for what cannot happen, compact answers and the output ceiling: docs/one-card-for-a-set.md. It changes what sections 2.3, 3.4, 4.4 and 4.5 below say (a run is confirmed once and goes to its end when its screens show what the card showed; the assistant creates no job; several records are one card through a table's bulk action); its section 6 lists each change.

Owner direction (2026-11-11): build all of it. The assistant in a QQQ application must be able to do everything the signed-in person can do, not only read, and the same abilities must be reachable from a person's own local agent over MCP.

The binding principle, in the owner's words: "the user that is logged in should always be the permissions boundary". Every tool call, every scheduled run and every MCP request runs as the person, with that person's current permissions and their own budget. Nothing in this design gives the assistant, a schedule or an outside agent more than the person holds.

The build rule, in the owner's words: "no local qbit source changes, all qbit changes go into their qbits, proper standards, code reviews, designs, architecture, etc and then proper code testing coverage, and rc releases". Every capability lands in the repository that owns it, with tests and a release candidate. An application only pins released versions and supplies configuration.

How to read this document: sections 1 to 11 are the design; section 12 is the work plan. "Today" means behaviour read in code at the refs listed in section 0. A name marked (proposed) does not exist yet.

0. What exists today

Read on 2026-11-11 at these refs. Section 13 names the file behind each statement.

Repository Ref read Latest release candidate
qbit-assistant origin/develop e02658d (same content as the tag) v0.1.0-RC.30
qqq (core) origin/develop 1e060bd25 v4.1.0-RC.32
qbit-data-analysis origin/develop ae57a94 (same content as the tag) v0.3.0-RC.2
qbit-email origin/develop e59b9e6 (same content as the tag) v0.1.0-RC.11
qbit-printing origin/main cf650c5 (no develop branch) v1.2.0-RC.3
qqq-frontend-next origin/main 787a227 (no develop branch) v1.0.0-RC.41
Area Today
Tool transport Every data tool is one spec'd /qqq/v1 operation called through core's UiApiInvoker with the person's own credentials and the client channel assistant/<turnId>. The assistant holds no session of its own (ArchUnit forbids constructing one).
Read tools list_tables, describe_table, query_records, count_records, get_record, search_records, render_widget, analyze_records, get_record_history (host opt-in), search_knowledge, search_help, navigate, present_results.
Write tools create_record, update_record, delete_record, save_analysis (a saved analysis and, when asked, a daily emailed schedule, on one card), bulk_profile_save, bulk_load_run.
Data access Since A2: the mode of a table or process is declared in code (READ_WRITE by default, a pin per object) and an assistant_data_access row can only narrow it. A table whose AI exposure is NONE, and every table of the assistant itself, stays NONE whatever anything says. Write tools are offered to a person who may change some table themselves. (When this document was written: without a row a table was READ and a process NONE, and write tools were offered only when some table had a READ_WRITE row.)
Confirmation A write tool inserts an owner-locked assistant_pending_action (15 minutes to live by default) and returns a card. POST /assistant/actions/{id}/confirm claims it, runs the stored operation with the confirming request's session, and records the outcome. Every write is confirmed: nothing switches confirmation off (the policy field writesRequireConfirmation is still in the schema and is no longer read; see 3.3).
The card Shows the summary and the proposed values only. No before values, no record line, no expiry (the panel receives expiresAt and does not draw it).
After a decision Confirming adds an assistant message to the conversation ("Done. ..." with links) and later requests annotate each earlier proposal with what became of it.
The wall Core denies the assistant channel every assistant_* object, identity and permission tables, audits, and anything named like a key, credential, secret, password or user session. The check runs in PermissionsHelper, beneath the assistant. qbit-assistant fails startup if one of its own objects is not denied.
Processes No tool runs a process. Process data access rows can be stored and have no effect.
Reports No tool creates or runs a core saved report.
Schedules save_analysis writes data_analysis_schedule (DAILY, a local time, an IANA time zone, the confirming person as recipient). It refuses a schedule that could never run, asking the host through withScheduledDeliveryCheck.
Email qbit-email's messaging bridge refuses any attachment ("Email attachments are not supported in part 1"). data-analysis sends through core SendMessageAction: an HTML summary with the first 20 rows, no link back to the application.
Budgets Records (assistant_budget), per person and shared, read at every question and before every model call. GET /assistant/config returns the person's own budgets since extension 1.8.0. The panel does not show them (it vendors extension 1.5.0).
Tool dispatch TurnEngine.executeTools chooses the tool family with an if-chain (presenter, kernel, knowledge, bulk load, toolbox) and AssistantApi.confirmAction repeats the choice for confirmed actions. There is no registry, and execution is tied to a chat turn.
MCP Nothing serves the assistant's tools over MCP.
Panel write switch The panel has a Read-only / Write switch driven by features.writeMode. The backend on develop never sends that feature and has no conversation write mode (an open draft, #21, would add one), so the switch never appears.

1. Goals and non-goals

1.1 What a person can now ask for, and what happens

The person says What happens
"Set the due date on order 1042 to Friday." The assistant reads the record as the person, proposes the change on a card showing the record, the field, its value now and its value after. Nothing changes until the person presses Save. The write then runs through the same operation the record screen uses, as the person.
"Delete the three test customers I created today." Three cards, each naming one record and showing what will go. A delete is confirmed one record at a time (see 3.4).
"Run the month-end close for October." The assistant finds the process among those the person may run, reads its inputs, asks for any it cannot fill, and proposes the run on a card listing the process, every input and the records it will run over. On confirmation it runs as a job the person owns, and the conversation reports progress and the result.
"Create a report of open orders by customer and send me the spreadsheet every Monday." A saved report the person owns and its schedule, on one card, with a preview of the first rows. The assistant says in one sentence why this is a report and not an analysis (see 5.1).
"Can you create a report for me? And schedule it to be emailed to me each morning at 9am? I want to see the number of printed documents from the last day, grouped by type." The owner's example. One conversation: at most one clarifying question (which field "type" means, if more than one fits), one card listing the saved analysis, what it shows, the filter, the schedule and time zone, who is emailed and the numbers as they are now, one confirmation, then a message with links to both records. Each morning the run executes as the person with their permissions of that morning and emails the result in the body and as an attachment.
"Stop sending me that report." The assistant finds the person's schedule, proposes switching it off on a card, and does so on confirmation.
"Load this file into products." Unchanged in shape (the bulk-load tools exist), now offered wherever the person may bulk load, without an administrator first opening the table.
From their own agent: "How many orders shipped yesterday, by carrier?" The agent calls the application's MCP endpoint, signed in as the person. The same tool, the same permissions, the same row caps. Health data is refused.
From their own agent: "Close ticket 77." The tool answers "proposed" with a link. The person approves in the application. The agent can ask what became of the proposal.

1.2 Non-goals

  • No path where the assistant, a schedule or an agent holds more than the person. No service account does business work on its own authority for these features.
  • No unconfirmed write. The switch that turned confirmation off is removed (see 3.3).
  • No new report engine. The assistant creates the two things that exist: a core saved report and a data-analysis saved analysis.
  • No tool that reads or changes the assistant's own configuration, identity, permissions, audits or secrets. The wall stays where it is, in core.
  • MCP is not a second API. It exposes the registered tools and nothing else. It does not expose /qqq/v1.
  • No unattended overnight agent. An MCP sign-in ends with the person's session (see 7.3). Unattended work is a schedule, which has its own identity model (section 6).
  • Sending anything to people other than the person (other recipients, channels) is out of the first slice. The schedule's recipient is the confirming person.
  • The existing administrator-defined scheduled assistant tasks (assistant_scheduled_task, which sign in with a stored credential reference for a designated account) are not changed and not used by this design. Moving them to the service identity model is recommended follow-up work, not part of this plan.

2. The permission model, in one place

2.1 Four layers, each of which can only narrow the one before

Layer Decided by Enforced in Can it widen?
1. The person's own permissions, record locks and field access The application's authentication (for example a verified token's policy claim) Core, on every /qqq/v1 operation the tool calls It is the boundary.
2. The channel wall Code (core defaults, each QBit's own rules, withDeniedClients on an object) Core PermissionsHelper, before anything that could allow access No. A channel never grants.
3. The assistant's data access and tool switches Code defaults, then an administrator's restriction qbit-assistant, before the operation is called No. Most restrictive wins.
4. Field exposure and classification Table and field metadata qbit-assistant and core's channel field policy No.

Layer 1 is why a person who cannot do something on a screen gets the identical refusal through the assistant: the tool result carries the operation's own status and message.

2.2 How one tool call is authorised

  1. The request is authenticated by the application's normal pipeline. In chat that is the person's browser session. Over MCP it is the person's bearer token (section 7).
  2. The person must hold assistant.hasAccess (chat) or assistant.mcp (proposed) (MCP).
  3. The kill switch is read fresh. The tool must not be switched off (2.5).
  4. The tool's own checks run: the table's or process's data access, field exposure, classification for the channel.
  5. The tool calls its /qqq/v1 operation through the invoker with the person's credentials and a server-set channel label. Core applies layers 1 and 2.
  6. The call is logged in assistant_tool_call with the person, the tool, the operation, the HTTP status the screen would have seen, and the channel.

Nothing in steps 3 to 6 can turn a refusal from step 5 into success.

2.3 Where confirmation is required

Action Confirmation Can an administrator switch confirmation off?
Any read None n/a
Create, update or delete a record The person, on a card, every time No (changed, see 3.3)
Save or edit a saved analysis or saved report The person, on a card No
Create, change, switch off or delete a schedule The person, on a card No
Run a process The person, on a card, before it starts; again at a review step (4.4) No
Bulk load The person, on a card, and again on the job (today's behaviour) No
Anything proposed over MCP The person, in the application, never in the agent No

A proposal can only be decided by the person who made it, in a session that is not the assistant's and not an MCP token (see 7.8).

2.4 Defaults are code

The defaults that decide what the assistant may do are declared in versioned code: QBit defaults in qbit-assistant, application choices in the application's configuration class. A deployed database holds only an administrator's restrictions on top of them, and each such row can only narrow. Section 3.1 gives the precedence.

2.5 What an administrator can restrict

  • A table: READ (the assistant never proposes writes to it) or NONE (the assistant cannot see it).
  • A process: NONE (the assistant cannot run or see it).
  • A tool: off, for everyone (proposed: disabledTools). The existing allowedTools allow-list stays.
  • The whole assistant: the kill switch (exists). MCP alone: the MCP kill switch (proposed).
  • Who may use chat (assistant.hasAccess) and who may connect an agent (assistant.mcp (proposed)): role permissions, granted in the identity provider.
  • Budgets: records, per person and shared (exist).

An administrator cannot grant. There is no setting that lets the assistant do what the person cannot.

2.6 What the model is never shown

Never shown Why it holds
A table, process, report or widget the person cannot use Core omits it from metadata and refuses it, exactly as on a screen.
The assistant's own configuration, conversations of other people, usage, tool logs Core's channel wall (assistant_*), plus the owner record locks.
Identity, roles, permissions, sessions, API keys, credentials, secrets, passwords Core's default deny patterns for the channel.
Audits (unless the host opts in to reading them; never writable) Core's audit* deny and write-deny patterns.
A field whose AI exposure is NONE or METADATA_ONLY Values never reach the model; NONE fields are refused as unknown.
A masked field's real value Core FieldValueMasker.
Health data, when the model provider is not eligible, or the caller is an outside agent The PHI routing rule (exists for chat; section 7.11 extends it to MCP).
Any secret value Keys are environment variable names, never stored, never logged.

Every QBit owns the wall for its own settings tables. The rule for QBit authors does not change: deny a settings or secrets table to the assistant channel. Requests made for an outside agent carry the same channel name (section 7.5), so one rule covers chat and MCP and there is no second list to keep in step.

3. Writes follow the person's permissions by default

3.1 The change to the data access model

DataAccessMode keeps its three values. What changes is the default and where it is declared.

Object Default today Default after Declared
Table whose AI exposure is NONE NONE, cannot be raised Unchanged Metadata
Any other table READ READ_WRITE AssistantQBitConfig.withDefaultTableAccess (proposed), default READ_WRITE
Process NONE READ_WRITE (the "run" mode) AssistantQBitConfig.withDefaultProcessAccess (proposed), default READ_WRITE

READ_WRITE means: the assistant may propose any write the person themselves may make. It grants nothing. The person's insert, edit and delete permissions, record locks and validation still decide, in core.

Precedence, most restrictive wins:

  1. Metadata: AI exposure NONE is NONE. A process denied to the channel is not there at all.
  2. Code ceiling (proposed): withTableAccess(tableName, mode) and withProcessAccess(processName, mode) on AssistantQBitConfig. An application or QBit pins an object at READ or NONE here, in versioned code. An administrator's row cannot raise it.
  3. Administrator restriction: an assistant_data_access row. It can lower the result of 1 and 2, never raise it.
  4. The code default from the table above.

DataAccessService.Decision.source reports which of the four decided, so "Explain access" and every refusal name the real reason ("pinned in code", "administrator setting", "default", "sensitive table").

Write tools are offered whenever the person can see at least one table that is not READ or NONE. The check UiApiToolbox.anyWritableTable() stays; it now answers true on any ordinary instance.

save_analysis loses its special requirement that an administrator set READ_WRITE on data_analysis_saved and data_analysis_schedule: both follow the default.

3.2 Migration of existing settings rows

Two kinds of row exist in a deployed assistant_data_access table, and they must be told apart:

  • Rows an administrator chose.
  • Rows written by the table action "Add rows for every table" (DataAccessDefaultsProcess), which stores the old default for every table that had no row: READ, or NONE where the table's AI exposure is NONE. Under the new precedence each READ row would be read as a restriction, and writes would stay off. The NONE rows change nothing, because those tables are NONE from their metadata.

The process stamps its rows with a fixed note (DataAccessDefaultsProcess.NOTE). The migration is a changeset shipped in the QBit jar beside the existing defaults changelog (proposed: db/liquibase/qbit-assistant/assistant-data-access-follow-user.changelog.sql), which a host includes in its own master changelog:

  • Delete rows where object_type = 'TABLE', mode = 'READ', notes equals the fixed note exactly, and create_date = modify_date (never edited).
  • Leave every other row. A row an administrator edited, or wrote by hand, keeps its meaning and now reads as a restriction.

The direction of any mistake is the safe one: a row wrongly kept leaves a table read-only for the assistant, which an administrator can see and remove.

DataAccessDefaultsProcess is retired in the same release, because materialising defaults as rows is what made this migration necessary. Its replacement is read-only: the Data Access screen and "Explain access" show the effective mode and its source for every table and process without storing anything.

UPGRADE.md gets a section that states the behaviour change in its first sentence, lists the changeset, and tells a host that wants the old behaviour how to keep it in code: withDefaultTableAccess(DataAccessMode.READ) and withDefaultProcessAccess(DataAccessMode.NONE).

What cannot be read from code: which rows exist in any deployed database. Before the release reaches an environment, an administrator opens Assistant > Data Access there and reviews the rows that will remain.

3.3 Confirmation is no longer optional

Until this design, assistant_policy.writes_require_confirmation = false made record writes run without a card. That was acceptable when an administrator had to open each table first. With writes following the person's permissions on every table, it would let a model change anything the person can change, unseen.

Decision (confirmed by the owner, and built): every write is confirmed. The column stays in the schema and is no longer read, and the policy record screen says so. (The startup WARN for a row that has it false was not built: the field's help says it has no effect.) The earlier design's "auto-confirm low-risk writes" (owner decision W, 2026-10-13) is withdrawn with it. Both are recorded in section 11 as changes to earlier owner decisions, because they are.

The per-conversation Read-only / Write switch from the same decision W is not on develop. It exists only as an open draft pull request in this repository (#21, write mode and auto-confirm rules). It is not needed: a person who does not want a change does not confirm the card. If decision D1 is confirmed, that pull request is closed rather than merged, and the switch, which never appears because the backend does not enable it, is removed from the panel (section 8).

3.4 The confirmation card

One card shape for every kind of proposal, with a body that depends on the kind.

Part Content
Heading The verb and the object in words: "Update Order 1042", "Delete Customer Test Co", "Run Month-end close", "Save the analysis ... and email it to you every day at 09:00".
Table and record The table's label and the record's label and key, as a link that opens the record in the application. For a create, the table's label.
Changes Update: one line per field with the field's label, the value now and the value after. Create: one line per field with the value. Delete: the record's visible fields, so the person sees what goes.
Preview For an analysis, a report or a schedule: the numbers or first rows as they are now. For a process: the inputs and the count of records it will run over.
Who and when For a schedule: the frequency, the local time, the time zone, the recipient.
Expiry The time the proposal lapses, as a countdown.
Origin "Proposed in this conversation" or "Proposed by your agent () over MCP".
Buttons The verb (Create, Save, Delete, Run, Schedule) and Cancel. Delete and Run use the destructive style.

Before and after values:

  • When update_record or delete_record is proposed, the tool reads the record with GET /table/{tableName}/{primaryKey} as the person. A record the person cannot read is refused there, with the operation's own message, and no card is made.
  • The values now of the fields being changed (for a delete, the visible fields) are stored on the pending action in a new column before_json (proposed), after the same exposure rules as get_record: a masked field shows masked before and after; a field the assistant may not see cannot be written and is refused as unknown, as today.
  • On confirmation the tool reads the record again. If any stored "value now" differs from the record's current value, the action fails with "This record changed after the change was proposed. Nothing was changed." and the conversation is told, so the assistant can propose again from the current values. This closes the gap between what the person approved and what would be written.

Several records: each record is its own pending action and its own card. The panel stacks consecutive cards of the same tool and table and offers "Confirm all N" (proposed), which confirms them one at a time and stops at the first failure. A delete is never part of "Confirm all".

Compatibility with a released panel: the released panel (1.0.0-RC.41) accepts a pending_action render only when toolName is one of create_record, update_record, delete_record; anything else is drawn as an unsupported result with no buttons. The backend therefore keeps sending one of those three in toolName and puts the real kind in actionKind (as save_analysis already does), so an application that upgrades the QBit before the panel still gets a working card, with less detail.

3.5 Expiry

A proposal lapses after pendingActionTtlSeconds (default 900, unchanged). The same value applies to a proposal made over MCP. An expired proposal can never run; the person asks again. The card shows the countdown and, once lapsed, says so without buttons. Expiry is evaluated on read and on decide, as today.

3.6 Audit

Record What it holds Exists
assistant_tool_call (proposal) The person, the tool, the redacted input, the outcome "waiting for confirmation", the pending action Yes
assistant_pending_action The plan, the values before, the status, who decided, when, the result, the channel and client (proposed columns: before_json, action_kind, channel, client_name) Yes, extended
assistant_tool_call (confirmed) The operation, its HTTP status, a link to the audit rows Yes
Core audit The person as the actor and the client channel (assistant/<turnId> in chat; assistant/mcp/<client> (proposed detail) for an outside agent) Yes, when the host turns the channel field on

A confirmed write is always attributed to the person. The channel says through which client.

Retention. Today a pending action is deleted only together with its conversation. The setting approvalRetentionDays (default 365) is declared, validated and described in the README as used by the retention process, but no code reads it. A proposal made over MCP has no conversation, so under today's code it would never be removed. This design makes the setting real: the retention process deletes decided and expired pending actions older than approvalRetentionDays, whether or not they belong to a conversation, and the README is corrected in the same change.

4. Running a process

4.1 Tools

Tool (proposed) Kind /qqq/v1 operation
list_processes read GET /metaData (the processes the person may use)
describe_process read GET /metaData/process/{processName}
run_process proposes on confirmation POST /processes/{processName}/jobs, or POST /processes/{processName}/init and .../step/{stepName}
get_run_status read GET /jobs/{jobId} and /progress, or GET /processes/{processName}/{processUUID}/status/{jobUUID}

4.2 Which processes a person can run through the assistant

A process is offered when all of these hold:

  1. Core lists it for the person on the assistant channel. A process the person has no permission for, or that is denied to the channel, is not in the metadata at all.
  2. Its data access is not NONE (the code default is the run mode; an application or administrator can pin it to NONE, section 3.1).
  3. It is not hidden, or it is a table's own action (the per-table bulk edit and bulk delete are hidden processes that the record list offers; the assistant offers them the same way, for that table).
  4. The assistant can supply everything its screens collect (4.3).

How a QBit author marks a process as not runnable by the assistant: QPermissionRules.withDeniedClients(Set.of("assistant")) on the process. This exists in core today, is enforced beneath the assistant, hides the process and refuses every operation on it. An application can do the same without touching the QBit, by name or by pattern, through ClientChannelsMetaData.

The default: a process the person may run is runnable through the assistant, with confirmation. That is the owner's direction, and it is a change (today every process is NONE). Because the default now opens rather than closes, each application gets a review gate (proposed): qbit-assistant ships a test helper that lists the processes a fully permitted person would be offered, and the application commits that list and asserts it in a test. A new process, in the application or in an upgraded QBit, changes the list and fails the build until someone has read the difference and either accepted it or denied the process. No process becomes runnable by the assistant without a reviewed line in version control.

As built, the reviewed list is registered in the application's code and enforced when it runs; a process that is not on it is not runnable, whether or not the application added the test. See 4.5.

QBits that own processes that should never be driven by a model (running SQL, restoring a backup, changing identity or permissions, controlling another person's job) deny them in their own next release. Core's default patterns already cover anything named like a credential, secret, password, permission or role.

4.3 Describing and gathering inputs

describe_process returns what a screen would show: the process's label, its table, how many records it needs (minInputRecords, maxInputRecords), and for each screen step its form fields (label, type, required, possible values) and its components.

The assistant gathers inputs in the conversation. It fills what the person said, reads possible values through the same operation the form uses, and asks one question for anything required and missing. It never invents a value for a required field.

Components the assistant can drive: help text, edit form, view form, record list, validation review, result summary, download, bulk edit form. A process with any other component (a folder picker, an embedded widget, the bulk-load mapping forms, anything unknown) is not run. The tool says so and returns a link that opens the process in the application with the records and values already filled (/app/{processName} with recordsParam and defaultProcessValues). Bulk load keeps its own tools.

4.4 The run

The card lists the process, every input with its label and value, and the records it will run over: for a selection, the count and the first few labels; for a filter, the filter in words and the count as it is now. Then one of two paths, chosen by the process's own metadata.

Path A, a durable job. Used when core reports the process as eligible to run as a job (durableJobEligible): by default the bulk processes and partitionable streamed processes, plus any process an application names. On confirmation the tool calls POST /processes/{processName}/jobs with the values and the filter or record ids. Core creates every job launched from the assistant channel as AWAITING_CONFIRMATION and refuses to start it from that channel. The panel, in the same click, starts the job from the person's own browser session (the job's Start action). So the model cannot start the work even if every check in the assistant failed: core will not let it. The job survives a restart, reports progress, and can be cancelled from the conversation or the jobs tray.

Path B, an interactive run. Used for every other process. On confirmation the tool calls init with the values and records, then steps forward until one of these:

The run reaches What happens
The end The result summary lines go to the conversation, with links to the records.
A validation review A second card: the preview message and count, with Validate fully, Continue and Cancel. Nothing is stored before the person answers.
A form with a required field that has no value The run stops there and the assistant asks. The person's answer continues the same run.
A download A link to the file.
A step that is still running when the tool's time limit ends The outcome is "still running", with a reference get_run_status can poll. The work continues on the server.

A run on path B lives in the memory of the replica that started it. The assistant already sends its calls to the replica that received the request, so a status check in the same conversation normally reaches it. A restart loses the run. Long work belongs on path A, and the review gate in 4.2 is where an application notices a long process that is not eligible and names it eligible (one line of configuration).

Refusals carry the operation's own message. A process the person may not run answers exactly as its screen does.

4.5 As built (package A4), and where it differs from 4.1 to 4.4

The package is built as tools/process in qbit-assistant. Where this section and the code disagree, the code is right; the differences, each with its reason:

  • A process the person may not run is refused in the words used for a process that does not exist, on the two lookups (describe_process, run_process), not with the operation's own "permission denied". The owner's rule is that a person is never told about a process they may not run. The operation's own status and message are what a person is told when the confirmed run itself is refused.
  • Two more processes are never runnable than 4.2 lists: one that no screen offers (in no app, and no table's action: for example the process the record screen calls to read a record's history), and one on a table the assistant may not change (a table an administrator made read-only for the assistant is not changed through its bulk edit).
  • A download is not drivable. 4.3 lists it; the assistant only ever emits links into the application (/app/...), and a file link is not one. The person is told to run the process in the application.
  • The link for a process the assistant cannot present is the process's place in the application (/app/{processName}), without records or values filled in: the panel's query parameters for that are the panel package's to define.
  • Path A sends no expected row count. Core starts an assistant-launched job by itself when the host set assistantAutoStartMaxRows and the launch names a row count under it. The assistant never sends one, so every job it creates waits for the person, on every host.
  • The review's second card is proposed, not created by the confirmation. A confirmation runs outside a turn and has nowhere to keep a new proposal. The run stops, its result (with a run reference) goes into the conversation, and run_process with that reference proposes going on: a new card, whose text about the run is what the server kept of it, never what the model passed. "Validate fully" is the same proposal with validateFully. A required field with no value works the same way.
  • get_run_status never moves a run on. A run that finished a background step and could go on is reported as waiting; going on is a proposal and a card.
  • A run over records is refused at confirmation when one of its records is gone: each record of the card is looked for again as the person when the run starts.
  • Possible values are not listed. describe_process says that an input has possible values; the value is passed as given and the process validates it. Listing them is left for the panel package or A5.
  • The review-list helper takes a session, or none. It lists what a person with that session's permissions could run through the assistant, or, with no session, what a person with every permission could (4.2's "fully permitted person"). It reads the code's data access only.
  • The reviewed list is enforced when the application runs, not only in its build. 4.2 makes the default "a process the person may run is runnable" and puts the review in a test the application adds. A gate that exists only where somebody added a test is no gate for the application that did not. As built, the application registers its reviewed list in AssistantQBitConfig (withReviewedProcesses, or withReviewedProcessesResource for a file on its classpath), and the tools run a process only when it is on that list. With no list registered, the only runnable processes are a table's own bulk edit and bulk delete: they act on records of a table the person may already change through the assistant. With a list: exactly the listed processes and those two, each still subject to every never-runnable rule, to an administrator's narrowing row and to the person's own permission. The helper of 4.2 stays, as the way an application notices drift: a process that could be listed and is not, a listed process that is gone, and a reviewed file that is not the registered list.
  • An input is only a field a screen asks a person for. A screen's field whose name the process keeps for its own working is not an input through the assistant (ProcessControlNames): the inputs the process's backend steps declare, and a fixed set this QBit owns (the names QQQ's streamed and bulk steps and its process runner read from a run's values, and the names the process operations carry a run's records in), checked against the QQQ version it builds with by a test. The person is told the field cannot be set through the assistant; the process stays runnable for its other fields.
  • A run stops at every later screen that has something to show, not only at a review and at a required field with no value (4.4's table): a form whose values a step may have computed, values to read, a text, a list of records. The second card shows what the screen shows; only a screen with nothing to show is passed. The screen a run starts at is on the first card.
  • The records of a run are fixed when it is proposed, by primary key, also for a filter (4.4 has the count "as it is now"; 4.5 above had the count compared at confirmation). A filter that finds more than 500 records is refused, for the person to narrow. The confirmed run is over exactly the records its card counted, and does not start when one of them is gone.
  • A card to go on carries the run's version. Every step and every stop of a run counts its version up; a card goes on only with the run as it stood when the card was made.
  • Path A has no fallback to path B. Where the application does not offer the operation that creates a job, a process that may run as one is not run through the assistant.
  • Text of the application reaches a model only inside the data envelope: a process's messages, what a screen shows, the application's message for a refusal or a failure. That holds for a result, for a card's lines, and for what a later request is told of an earlier process step or a confirmed run.

5. Reports and analyses

5.1 Which of the two the assistant creates

Saved analysis (qbit-data-analysis) Saved report (QQQ core)
It answers One number per group: a count, sum, average, minimum, maximum or distinct count, by one or two fields, optionally by date bucket Rows and columns: the records themselves, with chosen columns, a filter and optionally pivot tabs
The person sees A small table and a chart, in the application and in the email body A file: XLSX, CSV or JSON
Stored as data_analysis_saved (kind PIVOT, the definition as JSON), owner-locked savedReport (label, table, filter, columns, pivot), owned by the person
Typical request "how many ... by ...", "total ... per ...", "trend of ..." "a list of ...", "a spreadsheet of ...", "export ... every week"

The rule: a request for numbers by group is an analysis; a request for the records is a report. The owner's example ("the number of printed documents from the last day, grouped by type") is an analysis.

The assistant explains the choice in one sentence on the card's lead-in, and offers the other when it is a real alternative: "I'll save this as an analysis, because you asked for a count by type. If you want the individual print jobs as a spreadsheet instead, say so." When the request fits neither (more than two group-by fields, a calculation neither supports), it says what it cannot do instead of approximating.

Where an application has only one of the two, the other tool is not offered and the assistant says which it can do.

5.2 Tools

Tool Status What it does
analyze_records exists Answers a grouped question now, without saving.
save_analysis exists, extended (proposed: an id to change an existing one) Proposes a saved analysis, new or changed.
run_analysis (proposed) new Runs a saved analysis (POST /qbit/data-analysis/saved/{id}/run) and shows the result.
save_report (proposed) new Proposes a core saved report, new or changed, through the savedReport table's own insert or update.
run_report (proposed) new Renders a saved report through the renderSavedReport process and returns a link to the file, plus the first rows read with the report's own filter and columns.
schedule_delivery (proposed) new Proposes a schedule for a saved analysis or report, a change to one, or switching it off (section 6).

Finding an existing one needs no new tool: data_analysis_saved, savedReport and the schedule tables are ordinary owner-locked tables, read with query_records as the person.

Editing: the card shows the definition before and after in words (what it shows, the filter, the columns), never as raw JSON, and the same stale-record check as any update applies (3.4).

Showing a result: an analysis is presented as a table and, where it helps, a chart, through present_results. A report is a file; the conversation shows the first rows and the link.

One hard rule for run_report: it never fills the render process's email address field. Core's render step emails by making the stored file public and mailing a link to it (section 6.4). Delivery by email goes through section 6 or not at all.

6. Scheduling and delivery

6.1 The schedule record

Analysis schedule Report schedule
Table data_analysis_schedule core scheduledReport
When frequency (DAILY, WEEKLY, MONTHLY), day, time, or a cron cronExpression
Time zone time_zone (IANA) cronTimeZoneId
Recipients recipients: user ids, at most 100 toAddresses
Format format: HTML_SUMMARY, CSV, XLSX format
On or off enabled isActive
Owner the saved analysis's owner, through the join userId, fixed at insert
State last_run_at, last_status, next_run_at through the scheduled job

The first slice schedules analyses only, which covers the owner's example. Report schedules follow once core delivers scheduled reports safely (6.4, work package C1).

schedule_delivery writes these rows through their tables' own operations, as the confirming person. The recipient is the confirming person and nobody else in this plan.

6.2 Time zone

A schedule always carries an IANA time zone. The assistant uses the zone the person's browser reported (it is in the per-person context today) and says it on the card: "every day at 09:00 (America/Chicago)". With no zone known it asks; it never assumes one. The schedule's own code computes the next run in that zone, so daylight saving changes keep 9am at 9am. Over MCP there is no browser, so the tool requires the zone as an input.

6.3 Running as the owner

Nothing changes in the model; this design relies on it.

  1. A scheduler in the application starts the QBit's schedule process as a narrow service principal (data-analysis). The principal holds only what the bookkeeping needs.
  2. For each due schedule the QBit asks core for a session on behalf of the owner: ServiceIdentities.sessionOnBehalfOf(instance, principal, ownerUserId).
  3. Core asks the application's authentication customizer for the owner's access as it is now (customizeAutomatedSessionForUser). An application on an external identity provider reads the person's current groups there and resolves their permissions exactly as a sign-in does.
  4. The run executes in that session: the owner's current permissions and record-lock keys, nothing of the principal's. Writes and audits are attributed to the owner "via service:data-analysis".
  5. A person who is disabled or gone has no session, and the run fails closed. There is no fallback to the principal or to a system user.

A scheduled run makes no model call, so it spends nothing from the person's assistant budget. The assistant's part ended when the person confirmed the card.

Before proposing a schedule, and again on confirmation, the assistant asks the application whether a scheduled run could happen (withScheduledDeliveryCheck, exists) and refuses with what is missing. A schedule that would silently never run is never created.

6.4 Email: the result in the body and as an attachment

What exists and what is missing:

Piece Today Needed
The body data-analysis builds an HTML summary: headline numbers and the first 20 rows. No link back. A link to the saved analysis in the application, and a line saying how to stop the emails.
The attachment data-analysis builds analysis.csv or analysis.xlsx when the schedule's format asks for one. qbit-email's messaging bridge refuses any message with an attachment. qbit-email carries attachments.
The delivery path data-analysis calls core SendMessageAction directly. Unchanged in the first slice; then core's delivery action (below).

What qbit-email needs (work package E1):

  • Accept attachments on its messaging bridge and its own API, and declare the capability core checks for (STREAMING_ATTACHMENTS).
  • Store attachment content by reference in a QQQ storage table the application names, never as bytes in the outbox row and never on local disk (its own design decision D11). With no storage table configured it keeps refusing, with a message that names the setting.
  • Build multipart/mixed MIME for the transports that send raw MIME, and map attachments for the two transports that take JSON.
  • A size limit per message, a count limit, and an allow-list of content types (CSV, XLSX, PDF to start).
  • The health-data rule: an attachment is refused unless the message meets the same conditions its body must meet today.
  • Delete the stored content with the message under the existing retention.

Then the schedule's format is XLSX (or CSV), and the person gets the table in the body and the file attached.

The second step moves delivery onto core's delivery action (DeliverOutputAction with the EMAIL destination). Core already has it: it runs as the owner, refuses or sends a link only when the content's classification is above what email may carry, turns an attachment over the size limit into a link that requires sign-in, deduplicates by key, retries, logs to delivery_log (90 days), and notifies the owner when their session cannot be built. Today nothing produces into it: its only caller is its own retry process. data-analysis becomes its first producer (work package D2).

Core's scheduled reports must make the same move before the assistant schedules a report (work package C1). Today a scheduled report runs the render process with the recipients' addresses, and the render step then makes the stored file publicly readable and emails a link to it. Anyone who obtains the link can read the file without signing in. That is acceptable for no application that holds anything private, so this design does not use that path, and section 11 raises it as a finding in its own right.

6.5 Failures

What goes wrong Today After
The owner is disabled or removed The run fails, last_status says so, an alert is raised, every day, forever The same, and after 3 consecutive failures of this kind the schedule is switched off with the reason recorded
The owner lost a permission the analysis needs The run fails closed; nothing is sent The same, and the owner gets an in-application notification naming what is no longer available to them
Mail is refused, suppressed or bounces Recorded in last_status, alert The same, and after 3 consecutive refusals the schedule is switched off
The service principal has no credentials or was revoked Every schedule fails; core raises service_identity.unavailable and a health check goes down Unchanged. Schedules are not switched off for this: it is not the owner's failure
The attachment is too large n/a Step one: sent without the attachment, with a line saying so and the link. Step two: core turns it into a signed-in link

Switching a schedule off is a write by the QBit's own bookkeeping principal to a row it already maintains. It never widens anything.

6.6 Where report files are kept, and for how long

An application that defines saved reports on core's in-memory storage backend holds a rendered report in the memory of the pod that rendered it. Core's download authorisation is held in that pod's memory too, for 30 minutes. Such a file is lost on restart and cannot be fetched through another pod. On any backend, core has no retention for stored report files or rendered-report rows.

Proposed default (the owner decides, section 11):

  • A QQQ storage table on an object-storage backend, private, encrypted at rest, one prefix per environment. Core's storage action already streams to such a backend; the application passes the backend's name where it defines saved reports, and names the same or a sibling table for email attachments.
  • Never public. No public ACL and no presigned link for anything that is not classified PUBLIC. A link in an email is a link into the application that requires sign-in and checks the person's access.
  • Kept 30 days, then deleted: by a lifecycle rule on the bucket for the objects, and by a retention process for the rows that point at them (part of work package C1).
  • 30 days because a person returning from two weeks away should still find last month's file, and nothing older is needed when the report can be run again.

6.7 Stopping a schedule

  • In conversation: "stop sending me that" proposes switching the schedule off (enabled false) on a card showing the schedule before and after. Deleting it is a separate, explicit request.
  • In every email: a line with a link to the schedule in the application.
  • In the application: the schedule's own record screen, as today.
  • By an administrator: the schedule tables' screens; and pinning the schedule table to READ in code stops the assistant from creating new ones without touching existing ones.

7. MCP

7.1 What it is

One spec'd /qqq/v1 operation, POST /qqq/v1/assistant/mcp (proposed), served by the application's own web server and registered through the same extension point as the assistant's other operations. A request is authenticated, authorised, logged and answered by the pipeline every other operation uses. It speaks MCP's Streamable HTTP transport: a JSON-RPC request in, a JSON response out. It holds no protocol session.

It lives in the qbit-assistant module, package mcp (proposed), off unless the application turns it on in code. It adds no runtime dependency: the protocol subset needed (discovery or initialise, list tools, call tool, ping) is small, and the official SDK's own servlet transport would sit outside the /qqq/v1 pipeline. The official SDK's client is a test dependency, so conformance is checked against the reference implementation in every build.

Protocol revisions: the current revision is 2026-07-28 (confirmed on the specification's versioning page, 2026-11-11). As a researcher read it that day, it drops the initialise handshake and protocol sessions, requires server/discover, a protocol version header on every request and validation of the Origin header. The endpoint supports that revision and the one before it (2025-11-25), because released agents lag. The work package re-reads the pages it implements; this document does not restate the protocol.

7.2 The existing MCP repositories

Repository What it is Verdict
qbit-middleware-mcp A released QBit (v0.1.0-RC.2, on the Gitea registry) that mounts the MCP SDK's servlet in the application's server, authenticates each request with the caller's bearer token, and exposes its own per-table tools Reference, not the base
qqq-mcp-rag A standalone developer server that indexes QQQ source and patterns; no application data, no sign-in Unrelated; a reference for protocol tests
qqq-mcp-rag-standard-policies Pattern files for the above; no code Unrelated

Why qbit-middleware-mcp is not the base, read in its released code:

  • Its tools call core actions directly. update_<table> writes at once and run_process_<name> runs at once with screen steps skipped, when an application enables those operations. There is no proposal and no confirmation.
  • It has its own tool set, so chat and MCP would differ by construction.
  • It is a servlet beside /qqq/v1, so its sessions carry no client channel. The wall, the field exposure policy and core's confirmation gate for jobs are all keyed to the assistant channel and do not apply to it.

What it is good for: it proves the SDK servlet mounts under the application's server, and its HTTP security tests (a real SDK client, per-person data, no shared identity) are the model for section 9. Its own future is the owner's decision (section 11).

7.3 Sign-in for a local agent

The standard flow for a local program: OAuth authorisation code with PKCE against the identity provider, in the person's browser, with a loopback redirect. The person signs in as themselves, with their own second factor. The agent receives a short access token and a refresh token.

Piece Design
Discovery The application serves protected-resource metadata (RFC 9728) naming the identity provider as the authorisation server, and answers an unauthenticated MCP request with 401 and a WWW-Authenticate header pointing at it. This one document is a public route outside /qqq/v1.
Client One pre-registered public client per environment, used for MCP and nothing else. No secret. PKCE required. Redirects: loopback only. Access bound to the same group that may use the application.
Why pre-registered The identity provider's dynamic registration needs a token of its own, and it does not support client-ID metadata documents. Pre-registration is the specification's first choice in any case.
Audience Core's verifier accepts a token whose audience is a configured client id, and already checks issuer, signature, lifetime and token type. The specification asks agents to send a resource indicator; the identity provider's documentation does not mention supporting one (not verified either way). Because the client is used for nothing else, "issued to this client" is "issued for this endpoint", whether or not the indicator is honoured.
Token contents The access token itself must carry whatever the application's sign-in reads from a token: typically the person's email and a policy claim. Where permissions come only from that claim, a bearer session without it has none.
Lifetime Access token 5 minutes. Refresh token 12 hours, as an absolute limit. After that the person signs in again. The intent is that a removed role is gone within 5 minutes, because permissions come from the claim in each new access token. That holds only if the identity provider recomputes the claim on refresh, which is to be proven (7.13).
Idle limit Not enforceable with tokens alone: an agent that refreshes is not idle. An idle rule an application applies to browser sessions does not carry over to an agent. This is stated, not hidden (section 11).
No unattended agents Follows from the 12 hours. Overnight work is a schedule.

7.4 Confining the token to MCP

A person's MCP token must work at the MCP endpoint and nowhere else. Otherwise a local agent could call /qqq/v1 directly and skip confirmation, masking and the health-data rule.

  1. qbit-authentik gives a session whose token audience is the MCP client a credential scope listing only the MCP operation (proposed: withMcpClientId). Core already refuses every other operation for a scoped credential and labels its channel from the credential, ignoring any header.
  2. The MCP operation, having been authenticated by the pipeline, runs tools for that person through core's in-process session path: it registers a copy of the person's session, without the scope, under a random token that core accepts only from the loopback peer and only inside this process, for the length of one tool call, and revokes it afterwards.
  3. Those tool calls go through the invoker, which sets the channel on the server side.

So the scope removes everything except the endpoint, and the endpoint gives back only what the tools do. Step 2 is the one place where code deliberately holds the person's full session; it is small, it is the review focus of its work package, and section 9 tests that the token is refused everywhere else.

7.5 The channel

MCP tool calls carry the channel name assistant, with the detail mcp/<client> (proposed: assistant/mcp/<client>). Not a new channel. Core's wall, its default field policy and its job confirmation gate are keyed to the name assistant, and every QBit walls its own tables with that name. A second channel would start with none of those rules and would be open wherever one was forgotten. Logs and audits tell chat from MCP by the detail.

7.6 One registry, and the build test

Today the tool families are chosen by an if-chain in the turn engine and again in the confirm route. That is replaced by one registry (proposed, package tools.registry):

Type Role
AssistantTool One tool: its name, kind (READ, PROPOSE, DISPLAY), the channels it serves, whether it is offered to this person now, its definition, execute, and for a proposing tool executeConfirmed.
ToolRegistry Every tool, sorted by name. The only place a tool is looked up.
ToolCallService "Run one tool call for this person under this policy": kill switch, tool switch, classification for the channel, execute, log. The turn engine calls it for chat; the MCP operation calls it for an agent.

A new tool is one class that registers itself. It appears in chat and over MCP from the same definition object, so the two cannot describe it differently.

The build test: for every registered tool, either it serves both channels, or it is in a short explicit list of chat-only tools with a written reason. Adding a tool that is silently missing from MCP fails the build. The chat-only list at the start:

Tool Why chat only
present_results It draws in the panel. An agent formats its own answer.
render_widget It returns panel render shapes.
The bulk-load file tools They work on a file uploaded through the panel.

navigate is served over MCP and returns the application link as text.

7.7 The read-only phase

Only tools of kind READ are served. Proposing tools are registered and not listed. The same row caps, field masking and data access apply as in chat. Every refusal is the tool's ordinary refusal.

7.8 The write phase

A proposing tool, called over MCP, does exactly what it does in chat up to the proposal and then stops:

  • It answers status: proposed with the action id, a summary, the expiry, and a link into the application.
  • The person opens the application, signed in with their browser, and sees the card under Approvals (section 8), with its origin: "Proposed by your agent ()".
  • Confirming runs the action with the browser session, through the confirm operation that exists. An MCP token cannot call that operation: it is outside the token's scope, so core refuses it.
  • The agent learns the outcome with get_action (proposed, MCP only): pending, done, failed, cancelled or expired, with the result summary and links.

Nothing proposed over MCP is ever executed by an MCP request. A process run proposed over MCP on path A is additionally held by core until the person starts it.

7.9 Who may use it, and switching it off

  • A permission, assistant.mcp (proposed), granted per role in the identity provider. Holding assistant.hasAccess is not enough.
  • Off in code by default: withMcpEnabled(true) (proposed) in the application's configuration turns it on.
  • A kill switch for MCP alone on the policy record (proposed), read fresh on every request, for the day it must stop now. The existing kill switch stops MCP too.
  • In HIPAA mode the endpoint refuses to start. An outside agent's model provider is never an eligible provider.

7.10 Rate limits and budgets

A tool call over MCP makes no model call, so it costs the application no tokens. It still costs database work, and it moves data out. It is metered as what it is:

Limit Default (proposed, in code) Where it is counted
Calls per person per minute 30 In memory, per replica (as chat's limit is today)
Calls per person per day 600 A budget record with the new metric TOOL_CALLS, so an administrator can change it like any budget
Rows per call The policy's cap, as in chat (50) The tool
Rows per person per day 20,000 The same budget mechanism, metric ROWS

Each call writes a usage row of kind MCP with zero tokens and zero cost, so the home page shows MCP beside chat. The one tool that does cost money, search_knowledge (an embedding call), is charged to the person's cost budget exactly as in chat. A person at their limit gets the same sentence chat gives, naming the limit and when it starts again.

7.11 Health data and an outside agent

Whatever a tool returns over MCP goes to a model the application did not choose, outside its retention and any agreement. A person's own agent is therefore never eligible, and the rule is stricter than chat's:

  • A table or field is served over MCP only when it has an explicit classification and that classification is at or below the MCP ceiling. The ceiling defaults to CONFIDENTIAL and an application may raise it to PII in code. It can never be PHI.
  • An unclassified table is refused over MCP. In chat, unclassified means PUBLIC; for an outside agent, unknown is not good enough.
  • A refusal says why, without values: "This table is not available to an outside agent. Ask in the application's assistant."

A consequence: an application that has declared no classifications serves no table over MCP until it declares them in code. That is deliberate. The same declarations are what the chat's refusal of health data acts on, so an application should confirm it has them before it relies on either.

7.12 Telling MCP from chat

Record Chat MCP
assistant_tool_call.clientChannel assistant/<turnId> assistant/mcp/<client>
assistant_tool_call conversation and turn set empty
New column client_name (proposed) empty the agent's name and version as it declared them
assistant_usage kind TURN MCP (proposed)
Core audit.clientChannel (for a confirmed write) assistant/<turnId> assistant/mcp-approval/<actionId>
Access log channel assistant channel assistant, detail mcp/...

The Assistant home gets an MCP card: calls, people, refusals and proposals over 30 days. Message content and tool results are never logged, as today.

7.13 To be proven first

These are not established and are the first tests of the MCP work package, before anything is built on them:

  1. A copy of a bearer session, registered in-process, is accepted by the operations the tools call.
  2. A channel detail containing a slash is accepted and stored.
  3. The identity provider puts the email and policies claims in the access token of a public client.
  4. A public client with PKCE and a loopback redirect on any port completes sign-in on the deployed identity provider version.
  5. Which released agents accept a pre-registered client id, and which protocol revision each speaks.
  6. The identity provider recomputes the policies claim when a token is refreshed, so that removing a role takes effect within one access-token lifetime. If it does not, the refresh token lifetime is shortened until it does.

8. Frontend changes

All in qqq-frontend-next, whose only long-lived branch is main. qqq-frontend-core has no assistant code and is not touched.

Change Detail
Card registry Today one card component and a schema that accepts three tool names. Replace with a registry keyed by actionKind, with the existing card as the fallback for an unknown kind, so a newer backend never produces a card without buttons.
Record card The table and record as a link, each field with its value now and after, the expiry as a countdown, the origin line. Delete in the destructive style, showing what goes.
Confirm all Consecutive cards of the same tool and table (never deletes) get "Confirm all N", which confirms one at a time and stops at the first failure.
Process card The process, each input with its label, the records it will run over. Run, then for a durable job the Start call from the browser and a progress line fed by the jobs routes the tray already uses. A second card for a validation review.
Analysis and report cards What it shows, the filter in words, the columns for a report, a preview of the numbers or first rows.
Schedule card Frequency, local time, time zone, who is emailed, the format, and the next run. For a change: before and after.
Budget The person's own budgets from GET /assistant/config (budgets, present since extension 1.8.0, with a ready sentence per budget) shown in the panel, refreshed after each answer. Today the panel shows a budget only as an error once it is exhausted.
Approvals A list of the person's pending proposals that were not made in a conversation (new operation GET /assistant/actions?status=PENDING (proposed)), reached from a badge on the assistant button and from a notification in the existing notification centre. A deep link opens the panel on one proposal (proposed: ?assistant=open&assistantAction=<id>, beside the existing assistantPrompt link).
Remove the write switch The Read-only / Write switch and its unused types go. The backend never enabled it.
API document Vendor the assistant extension's document at its new version; the contract test fails on any call not in it.

Every card kind keeps the rule that a card whose action has lapsed, or was decided elsewhere, shows its state and no buttons.

9. Tests

Each repository keeps its own gates green (for the three Java QBits: Checkstyle, and JaCoCo at 70 percent of instructions and 90 percent of classes). On top of that every work package meets the standards' bar for changed code, 80 percent of changed lines, and the classes that decide access (the registry and tool-call service, data access, pending actions, the MCP operation) are covered completely. Test data is synthetic. No test is reported as passing unless it was run.

9.1 Per repository

Repository Tests this design adds
qbit-assistant Registry: every existing golden and red-team task passes unchanged through the registry (the refactor changes no behaviour). Data access: the precedence table of 3.1 as a parameterised test; the migration changeset run twice against a fresh schema and against a schema with materialised and hand-written rows. Cards: before and after values, masked fields, the stale-record refusal, expiry, one decision only, owner only. Processes: both paths against the fixture server, each stop point of 4.4, an undrivable component, the review-list helper. Reports and schedules: the save and edit round trips, the hard rule that the render email field is never filled. Retention of pending actions with and without a conversation.
qbit-email Attachments through the bridge and the API; MIME structure per transport; size, count and type limits; refusal with no storage configured; the health-data rule; retention deletes stored content; resend carries the attachment.
qbit-data-analysis Body with link; body plus attachment through a real qbit-email (test dependency, as the assistant does with data-analysis); switch-off after three failures of one kind and not for a principal outage; the per-recipient run still uses that recipient's access. Later, delivery through core's action: classification above the ceiling becomes a link, oversize becomes a link, a repeated key sends once.
qqq (core) Scheduled reports deliver through the delivery action; no code path makes a stored report public; retention removes old files and rows; whatever the MCP proof (7.13) shows to be missing.
qbit-authentik A token for the MCP client yields a session scoped to the MCP operation; any other audience is unaffected; a missing or malformed audience yields no permissions.
qqq-frontend-next Unit tests per card kind including the unknown-kind fallback; the countdown with an injected clock; Confirm all stops on failure and skips deletes; the budget line; the approvals list and deep link. An end-to-end spec for a pending action from proposal to done (none exists today).

9.2 The owner's sentence, end to end, with a scripted model

In qbit-assistant's eval suite, run in every build, with the scripted provider, a fixed clock, the fixture server, a local service principal and a recording mail provider. The fixture has a print-job-like table with a real date-time and two fields that could be "type".

  1. The person sends the sentence. The script has the model describe the table and, finding two candidate fields, ask one question. Assert exactly one question and no proposal yet.
  2. The person answers. The script calls analyze_records (a count by that field, filtered to the last day with a relative date), then save_analysis with a schedule at 09:00 in the person's zone.
  3. Assert one pending action and one card: what it shows, the filter in words, the schedule and zone, "Emailed to: You", and the numbers as they are now.
  4. Confirm as the person. Assert a saved analysis and a schedule exist, both owned by the person, the schedule's recipient is the person, its format carries an attachment, and the conversation has the "Done." message with two links.
  5. Move the clock to 09:00 the next day in that zone and run the schedule process as the service principal. Assert one message to the person's address, the table in the body, a link back, and one attachment whose rows equal a direct grouped query run as the person.
  6. Remove the person's read permission on the table and run the next day. Assert no message, a failed status that names the reason, and an in-application notification to the person.
  7. Run twice more. Assert the schedule is switched off with the reason recorded.

The same conversation is a manual acceptance step on dev with the real model, recorded in the application's own checklist.

9.3 Security tests

Property Test
A person never gains what they lack For fixture people with different permissions, for every registered tool: the assistant's outcome equals the status and message of the same operation called directly with that person's session. The existing denial matrix, extended to process init, job launch, saved report and schedule writes.
No write without a decision A recording gateway asserts that during any turn, and during any MCP request, no operation other than reads is invoked. Writes appear only under the confirm operation. The policy row with confirmation off changes nothing.
What was approved is what is written A record changed between proposal and confirmation is not written.
The default did not open the wall With no settings rows, an administrator through the assistant is still refused every configuration, identity, audit and secret table, and those tables are absent from list_tables.
A revoked role stops a schedule Step 6 above.
A removed person stops a schedule The run fails closed and nothing is sent; no fallback session is ever built (assert on the session factory).
MCP cannot reach a hidden table A person without read on a table: it is absent from the tool's list, and a direct call for it is refused with the operation's own message.
An MCP token works nowhere else Every other spec'd operation, called with the token, is refused. The confirm operation is among them.
An outside agent gets no health data An unclassified table, a PII field above the ceiling and a PHI table are each refused over MCP while chat with an eligible provider is answered.
MCP writes nothing In the write phase a proposing tool creates a pending action and invokes no write.
Chat and MCP expose the same tools The registry test of 7.6.
Hostile input Malformed JSON-RPC, an oversized body, a bad Origin, an unknown protocol version: each a clean refusal, never a stack trace.

10. Repositories, order and releases

Release candidate numbers are the next on each line as of today; a number shifts if another change releases first.

Order Repository Change Release
1 qbit-assistant Build against QQQ 4.1.0-RC.32 (today RC.25); tool registry and tool-call service, no behaviour change 0.1.0-RC.31
1 qbit-email Attachments 0.1.0-RC.12
1 qbit-data-analysis Link in the body, attachment with the body, switch-off after repeated failures 0.3.0-RC.3
2 qbit-assistant Writes by default, the card data, process tools, report and schedule tools 0.1.0-RC.32
2 qqq-frontend-next Card registry and the cards of section 8, budget, switch removed 1.0.0-RC.42
3 qqq (core) Scheduled reports deliver through the delivery action; nothing made public; retention 4.1.0-RC.33
3 qbit-data-analysis Delivery through core's action 0.3.0-RC.4
4 qbit-authentik A session for the MCP client is scoped to the MCP operation 0.1.0-RC.14
4 qbit-assistant MCP, read-only 0.1.0-RC.33
5 qbit-assistant MCP proposals, get_action, approvals list 0.1.0-RC.34
5 qqq-frontend-next Approvals 1.0.0-RC.43

Rows with the same order number can be built at the same time. Release 0.1.0-RC.31 of the assistant is a pure refactor on purpose: an application can run it for a day and see nothing change before the release that changes behaviour.

10.1 What an application then pins and configures

An application changes no QBit source. It changes its pins, its own configuration classes, its database changelog and its deployment values. What a particular application pins today, and what blocks it, belongs in that application's own repository, not here.

Slice Pins Configuration
Writes, processes, reports, the example qbit-assistant and its model provider module 0.1.0-RC.32; qbit-email 0.1.0-RC.12; qbit-data-analysis 0.3.0-RC.3; qqq-frontend-next 1.0.0-RC.42. Where the example's table is print jobs: qbit-printing 1.2.0-RC.3, the release that lets a holder of the printing administrator permission group them. New changesets: the QBit's data-access migration, the new pending-action and tool-call columns, the email attachment storage. The committed process review list and its test. Optional pins in code for tables that must stay read-only. A storage table for attachments. Role permissions for whoever should see the example's numbers.
Scheduled reports core 4.1.0-RC.33; qbit-data-analysis 0.3.0-RC.4 Saved reports with scheduling on; the report storage backend.
MCP read-only qbit-authentik 0.1.0-RC.14 (where the identity provider is Authentik); qbit-assistant 0.1.0-RC.33 The MCP client id, and bearer tokens accepted. Where the application's own authentication customizer strips bearer sessions by default, one condition so a session for the MCP client keeps what its claim gives. withMcpEnabled(true). Classifications declared in code. assistant.mcp published and granted to the roles that get it. In the identity provider: the public client.
MCP writes qbit-assistant 0.1.0-RC.34; qqq-frontend-next 1.0.0-RC.43 Nothing new.

10.2 What cannot reach an environment without a decision or a secret

Capability Needs
Writes by default; running a process Nothing beyond pins and changesets. An administrator reviews the data-access rows that remain and the process review list.
Creating the analysis and its schedule in conversation Nothing new. It works today where an administrator opened the two tables; after the release it needs no setting.
The scheduled run itself A service identity for the schedule principal in that environment: a service account at the identity provider and its secret in the environment's secret store.
The attachment A storage backend for attachment content in that environment (decision D2).
The example's data The printing release above, and a role decision: grouping print jobs needs the printing administrator permission and the analyse permission on that table.
Scheduled reports The core release, then decision D2.
MCP Decision D4 (the public client), decision D3 (classifications), the proofs of 7.13, bearer tokens accepted in that environment.

11. Risks, findings and decisions

11.1 Decisions for the owner

Decision Recommendation
D1 Today's direction replaces two decisions of 2026-10-13: that the policy may switch confirmation off (and low-risk writes may auto-confirm), and the per-conversation Read-only / Write switch. Confirm. Every write is confirmed; there is no switch. Decided 2026-11-12: confirmed. Also decided that day: writes follow the person's own permissions by default, defaults live in versioned code and an administrator's row can only narrow them; and the assistant answers nobody while no spending limit is in force.
D2 Where report files and email attachments are kept, and for how long. A private object-storage backend behind a QQQ storage table, 30 days, links that require sign-in, nothing public.
D3 Which tables and fields of each application are health data, declared in code; and whether PII may reach an outside agent. Declare them before MCP is turned on anywhere. PII: no, to begin with.
D4 Sign-in for a local agent needs a public client with loopback redirects. An identity provider set up for confidential clients with exact redirects only does not allow one, so this is a change of rule there, not just a new entry. One dedicated public client per environment, used only for MCP, PKCE required, loopback redirects only. Dev first.
D5 qbit-middleware-mcp is released and offers direct, unconfirmed writes and process runs to a signed-in caller when an application enables them, outside the wall. Do not add it to an application that has the assistant. Decide its future separately; at the least, its write and process tools should propose, not execute.
D6 Core emails a saved report by making the stored file public. Treat as a defect. Fix in core (work package C1) before any application turns scheduled reports on.

11.2 Decided in this design

Choice Decided Why
The channel for MCP The assistant channel with an mcp detail Every existing deny rule, the field policy and core's job gate are keyed to that name.
Where MCP lives A package in qbit-assistant, a spec'd operation, no SDK at runtime One build holds the registry and both of its users; the pipeline is the normal one; no new dependency.
Process default Runnable where the person may run it, with the committed review list The owner's direction, with a gate that makes every newly runnable process a reviewed change.
Several records One card per record; "Confirm all" for non-deletes The person sees each change; deletes are never batched.
What was approved Re-read on confirmation and refuse if changed The card must describe what is written.
Expiry 15 minutes, in chat and over MCP One number to explain.
First slice of schedules Analyses only It covers the example, and core's report email path is not safe to use.
Unclassified data over MCP Refused Unknown is not public when the reader is an outside model.
MCP idle limit Not enforced; 12 hours absolute, 5 minute tokens Tokens cannot express idleness. Stated rather than implied.
Tool calls without a model call Metered as calls and rows through the budget records They cost no tokens; they still need a limit an administrator can change.
"Add rows for every table" Retired Storing defaults as rows is what the migration has to undo.
A failing schedule Switched off after 3 consecutive failures caused by its owner or its mail An alert every morning forever helps nobody.

11.3 Findings outside this design's scope

Reported, not changed here:

  • qbit-assistant, qbit-data-analysis and qbit-authentik build and test against QQQ 4.1.0-RC.25 or RC.26, while the current core release candidate is RC.32.
  • The pom of qbit-printing at its v1.2.0-RC.3 tag still carries an older version number. Whether the published artifact is versioned from the tag was not verified.
  • data-analysis refuses an attachment up front when the provider is core's own email provider, saying it does not support attachments. Core's email provider declares that it does. One of the two is out of date; work package D1 settles it.
  • The repositories' coverage gates (70 percent of instructions) are below the standards' bar for published libraries. This design sets a higher bar for its own changes and does not change the gates.

11.4 Risks

Risk Mitigation What remains
The default opens writes and processes on every table and process at once The person's own permissions still decide; every action is confirmed; the review list; pins in code; a pure-refactor release first An administrator must look at the remaining data-access rows in each environment once.
Text in a record persuades the model to propose something harmful The card is built by the server from real values, not from the model's words; before and after; deletes one at a time A person who confirms without reading. The destructive style and the record link are the only defence.
Record writes have no gate beneath the assistant Proposal-only is enforced by the tool layer and tested with a recording gateway; job launches do have a core gate A defect in the tool layer could write as the person, within the person's own permissions. A core write-deny keyed to the channel detail would close it and is worth considering later.
An interactive process run is lost on restart Durable jobs for eligible processes; the review list is where a long process is made eligible Short processes only on path B.
Data leaves through an outside agent's model The classification ceiling, refusal of unclassified data, row and call limits, a role permission, two kill switches Whatever is classified CONFIDENTIAL or below and readable by the person can be read by their agent. That is the feature.
A stolen MCP token 5 minute access tokens confined to the MCP operation; writes need the browser A stolen refresh token reads as the person for up to 12 hours. Disabling the person, or the MCP kill switch, ends it.
Released agents differ in what they support The acceptance step names the agents tried Some agents may not connect until they support a pre-registered client.
Many releases across six repositories The order of section 10; one behaviour-changing assistant release per slice A release that slips delays the slices after it.

12. Work plan

Sizes: S is a couple of days, M about a week, L up to two weeks, for one agent including tests and review. Every package: a branch from the repository's integration branch (develop, or main where there is no develop), a draft pull request, the repository's full verify with no gate skipped, a changelog entry, an upgrade note where behaviour or schema changes, and review before merge. No package touches a release/* or main branch directly; releases are cut by the repository's own release workflow.

Packages in the same slice touch different files. A1 goes first and alone because it moves the code the others add to; after it, each tool family is its own package of new files.

12.1 Packages

Package Repository Size Depends on Slice
A0 Build against QQQ 4.1.0-RC.32 qbit-assistant S none 1
A1 Tool registry and tool-call service qbit-assistant L A0 1
A2 Data access defaults in code, migration qbit-assistant M A1 1
A3 Pending actions: before and after, kinds, list, retention qbit-assistant M A1 1
A4 Process tools qbit-assistant L A1 1
A5 Report and schedule tools qbit-assistant M A1 1
A6 The end-to-end scenario and the extended security matrix qbit-assistant M A2 to A5, D1's release (its test dependency) 1
E1 Attachments qbit-email L none 1
D1 Body link, attachment, switch-off qbit-data-analysis M none (E1 for its integration test) 1
F1 Card registry, record card, budget, switch removed qqq-frontend-next M A3's API document 1
F2 Process cards and job start qqq-frontend-next M F1, A4's API document 1
F3 Analysis, report and schedule cards qqq-frontend-next S F1, A5's API document 1
G1 Pins, changesets, review list, storage the adopting application (its maintainers) M the slice 1 releases, D2 1
C1 Scheduled reports through the delivery action; retention qqq L D6 1b
D2 Delivery through core's action qbit-data-analysis M D1 1b
M0 The proofs of 7.13 qbit-assistant (test code only) and a dev identity provider S A0, D4 2
M1 MCP operation, read-only qbit-assistant L A1, M0 2
M2 MCP client scope qbit-authentik S M0 2
G2 MCP configuration, classifications, public client the adopting application and its identity provider (their maintainers) M M1, M2, D3, D4 2
W1 MCP proposals, get_action, approvals list and notification qbit-assistant M M1, A3 3
F4 Approvals qqq-frontend-next M F1, W1's API document 3

12.2 Package detail

A0. Build against the QQQ version applications run. Branch build/qqq-4.1.0-rc32. Root pom.xml only (qqq.snapshot.version) plus whatever the newer core makes fail. Tests: the whole suite, unchanged, green. Review: nothing but the version and forced fixes.

A1. Tool registry and tool-call service. Branch refactor/tool-registry. New package tools/registry (AssistantTool, ToolRegistry, ToolCallService, the proposal contract types used by A3 to A5). TurnEngine.executeTools, ContextBuilder.tools and AssistantApi.confirmAction call the registry instead of choosing a family. UiApiToolbox, AnalysisTools, BulkLoadTools, KnowledgeTool and PresentResultsTool become registered tools with their behaviour untouched. Tests: every existing test passes without edits to its assertions; a new test that the registry's definitions equal the previous list byte for byte (the cached request prefix must not change); the ArchUnit rules extended to the new package. Review: that nothing changed. Any behaviour change is a defect in this package.

A2. Data access defaults in code. Branch feat/data-access-follows-the-person. access/, AssistantQBitConfig (the two defaults and the two pins), PolicyService (confirmation always), processes/DataAccessDefaultsProcess removed, the migration changeset and its test, UPGRADE.md, README.md. Does not touch the tool classes or the store. Tests: 9.1. Review: the precedence, the migration's delete condition, that nothing can raise a table whose exposure is NONE.

A3. Pending actions. Branch feat/pending-action-detail. model/AssistantPendingAction, the pending action section of AssistantStore, the record-write tool (before values, the stale check), the actions part of AssistantApi and AssistantSpecs with the API document (actionKind, before values, the list operation), AssistantRetentionStep (pending actions), docs/schema-postgres.sql. Tests: 9.1 and the "what was approved" row of 9.3. Review: masking of before values, the claim that prevents a double run, that the released panel still gets a working card.

A4. Process tools. Branch feat/process-tools. New package tools/process only, plus its help text. Tests: both paths, every stop point, an undrivable component, a denied process, the review-list helper. Review: that no input is invented, that path A never starts a job itself, that refusals are the operation's own.

A5. Report and schedule tools. Branch feat/report-and-schedule-tools. New package tools/reports; AnalysisTools for editing and the schedule format. Tests: 9.1. Review: the render email field is never set; the recipient is always the confirming person; a schedule is refused when it could not run.

A6. The scenario and the matrix. Branch test/actions-end-to-end. Test code only: 9.2 and 9.3 for slice 1. Review: that each assertion would fail if the property were broken (each is shown failing once against a deliberately broken build, and the output kept in the pull request).

E1. Attachments. Branch feat/attachments. The bridge, the API request, the outbox service, the tables and DDL, the dispatcher and envelope, MIME, the two JSON transports, retention, the resend path. Tests: 9.1. Review: no bytes in the outbox row or on disk; limits; the health-data rule; that a message without attachments is byte-identical to today's.

D1. Schedule email. Branch feat/schedule-email-body-and-file. schedule/ScheduleRunner and its tests, saved/AnalysisExport. Tests: 9.1. Review: the link is an application link; the switch-off counts only failures that are the owner's or the mail's; the per-recipient run is unchanged.

F1 to F4. Branches feat/assistant-card-registry, feat/assistant-process-cards, feat/assistant-report-cards, feat/assistant-approvals, each from main. F1 creates the registry and one file per card kind (the later kinds as placeholders that render the fallback), so F2 to F4 each edit only their own files. Tests: 9.1. Review: the fallback for an unknown kind, accessibility of the before and after list, that Confirm all cannot include a delete.

C1. Scheduled report delivery. Branch fix/scheduled-report-delivery. The scheduled-report and render steps, the delivery producer, a retention process for report files and rows. Tests: 9.1. Review: that no call to make a stored object public remains on any report path; the owner session; idempotency.

D2. Delivery through core. Branch feat/deliver-through-core. ScheduleRunner builds a delivery request instead of a message. Tests: 9.1. Review: the classification passed is the highest of the fields in the result.

M0. Proofs. Branch test/mcp-proofs. Six tests, one per item of 7.13, the first two against the fixture server and the rest against a dev identity provider. Its result decides whether core needs a change; if it does, that change is its own small package in qqq before M1.

M1. MCP, read-only. Branch feat/mcp-read-only. New package mcp (the operation and its spec, the JSON-RPC handling, the metadata route, the in-process session step, the classification rule for the channel, the metering), the assistant.mcp permission, the two budget metrics, the usage kind, the home card, the README section on connecting an agent. Tests: 9.3. Review: the in-process session step (its lifetime, its revocation in every exit path, that nothing but tool calls can use it); that proposing tools are not listed; input handling.

M2. MCP client scope. Branch feat/mcp-client-scope. The customizer and its configuration. Tests: 9.1. Review: fail closed on anything unexpected in the token.

W1. MCP proposals. Branch feat/mcp-proposals. The mcp package (proposing tools listed, the proposed answer, get_action), the notification, the origin fields. Tests: the last rows of 9.3. Review: that no MCP request can reach the confirm path.

G1 and G2. The adopting application's, in its own repository and its deployment and identity configuration, after the releases they pin. Listed so their inputs are known; not for a QBit agent.

12.3 The first slice for dev

A0, A1, then A2, A3, A4, A5, E1 and D1 in parallel with F1; then F2 and F3; then A6 and G1. Result on dev: writes follow the person's permissions with a card for each, a person can run a process they may run, and the owner's sentence works in one conversation up to and including the confirmed schedule. The 9am email itself arrives once the dev service identity and the attachment storage are in place (10.2).

Then MCP read-only (M0, M1, M2, G2). Then MCP writes (W1, F4). Scheduled reports (C1, D2) can run beside either.

13. Evidence

Read directly for this design unless marked (R), which means read by a researcher working for this design and not re-read; those are to be confirmed by the package that depends on them.

Statement Where
Defaults READ and NONE; exposure NONE cannot be raised qbit-assistant access/DataAccessService.java forTable, forProcess
Write proposal, the card's fields, the unconfirmed branch tools/UiApiToolbox.java write, runWrite
Confirm, claim, decision message api/AssistantApi.java confirmAction, reportDecision, expireIfDue
The person's own budgets in /config api/AssistantApi.java config, ownBudgets
Tool dispatch by if-chain engine/TurnEngine.java executeTools; engine/ContextBuilder.java tools
Save and schedule an analysis on one card tools/AnalysisTools.java proposeSave, confirmSave, scheduleBlockers
The fixed note on materialised rows processes/DataAccessDefaultsProcess.java NOTE
approvalRetentionDays unused; pending actions deleted with the conversation AssistantQBitConfig.java; processes/AssistantRetentionStep.java; persistence/AssistantStore.java
The wall is validated at start metadata/AssistantChannelWall.java; AssistantRuntime.java
Channels, deny rules, the default wall qqq model/metadata/permissions/ClientChannelsMetaData.java; docs/UI-API-CLIENT-CHANNELS.md
A scoped credential's channel is forced; in-process sessions are loopback only qqq executors/ExecutorSessionUtils.java; specs/invoke/UiApiInProcessSessions.java; specs/invoke/UiApiInvoker.java
A scoped credential is refused outside its operations qqq specs/AbstractEndpointSpec.java
Assistant launches wait for confirmation; only pause and cancel from the channel; eligibility qqq jobs/DurableJobs.java launch, control, isEligible, isAssistant
Service identity, on behalf of a person qqq docs/SERVICE-IDENTITY.md; serviceidentity/ServiceIdentities.java (R)
Saved-report email makes the file public qqq processes/implementations/savedreports/RenderSavedReportExecuteStep.java; filesystem module S3StorageAction.makePublic
The delivery action: owner session, classification, size, log, notification qqq delivery/DeliverOutputAction.java, EmailDeliveryDestination.java
The delivery action has no producer qqq: the only call outside tests is in delivery/DeliveryRetryProcess.java
Saved report and scheduled report tables, render process, storage, no retention qqq model/savedreports/*, RenderSavedReportMetaDataProducer.java (R)
Process metadata for a client; no AI metadata on processes qqq ProcessMetaDataLight, FrontendStep, QProcessMetaData (R)
Email refuses attachments qbit-email bridge/EmailOutboxMessagingProvider.java sendMessage
Schedules send through SendMessageAction; 20 rows; never switched off qbit-data-analysis schedule/ScheduleRunner.java
Schedule and saved-analysis fields, permissions, sessions qbit-data-analysis model/DataAnalysisTables.java, schedule/AnalysisSessions.java, engine/AnalysisSecurity.java (R)
Grouping print jobs needs the printing administrator permission; created_time; format qbit-printing PrintingReadPermission.java; PrintingQBitProducer.java (R)
The card accepts three tool names; expiry not drawn; no budget shown; extension 1.5.0 vendored qqq-frontend-next src/lib/api/assistant-normalize.ts; src/types/assistant.ts; src/lib/api/openapi/extensions/assistant.json
Panel routes, events, global surfaces qqq-frontend-next src/lib/api/assistant.ts, src/components/assistant/*, src/lib/api/alerts.ts, jobs.ts (R)
qbit-middleware-mcp is released; its tools call core actions; its filter its origin/main at v0.1.0-RC.2: tools/UpdateToolHandler.java, RunProcessToolHandler.java, transport/McpBearerAuthenticationFilter.java
The token verifier's checks; the claim mapper; current-access lookup qqq OAuth2BearerTokenVerifier; qbit-authentik AuthentikPolicyClaimMapper, AuthentikGroupPermissionMapper (R)
The current protocol revision the specification's versioning page, read 2026-11-11
What the 2026-07-28 revision changed; registration options; the identity provider's registration support; SDK versions the specification and vendor pages (R)