Commit Graph
131 Commits
Author SHA1 Message Date
james.maesandClaude Fable 5.2 efe161a94d fix(process): a review's own inputs and values are held to what the card showed
A review was passed on its count and its lines alone. A review with an
option whose value the process had changed after the card was made, or with
a value to read, went on to store with what the card never showed (proved
by a second independent review).

A review is a screen too: before it is passed, and before it is answered
with "validate", what it has of its own is held to the record of what the
card displayed (screenDiffers), like any other screen. Such a run stops
with nothing stored, and the card to go on with shows the review's inputs
with the values the process holds now and its values to read. The values
the card gave for a review's own inputs are sent with its answer.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 15:53:05 -06:00
james.maesandClaude Fable 5.2 a5b5f8cc4a test: the tool-set file follows the description of get_run_status
maven / build (push) Successful in 10m8s
build / maven (push) Successful in 10m8s
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 13:43:34 -06:00
james.maes df24de71fe Merge branch 'fix/render-widget-follows-data-access' into feat/one-card-for-a-set
# Conflicts:
#	CHANGELOG.md
2026-11-17 13:41:14 -06:00
james.maesandClaude Fable 5.2 647a8eadfb fix(process): a screen is passed only against the record of its card; a review is judged before any step; an unread job is not described
Three cases an independent review proved against the first version, each
with a test that fails without its fix:

- a review with a warning and an error was answered with 'validate first'
  before its lines were read, and a process that is not core's streamed one
  went on to store. The lines are now judged first, for every process, and
  'validate first' is only answered for core's own streamed process; a
  review with no lines is not passed.
- a screen outside the process's list of steps (an optional step), with a
  defaulted option, was passed although the card never displayed it. The
  stored proposal now keeps a record of what the card displayed, and a screen
  is passed only against it; a screen the process changed while it ran and
  every screen of a state-machine process stop.
- a job the person may not read was reported as running. A job that was not
  read is reported as exactly that, and the action fails.

Also: a status check cancels nothing; a run still working is 'started and
has not finished'; the names on a card are in the application's order;
every input is on the card, also one left empty.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 13:40:24 -06:00
james.maes 2f615879ba Merge branch 'fix/tool-call-admission-does-not-pin' into fix/render-widget-follows-data-access
maven / build (push) Successful in 11m20s
build / maven (push) Successful in 11m20s
# Conflicts:
#	CHANGELOG.md
2026-11-17 13:27:56 -06:00
james.maesandClaude Fable 5.2 1b7e92897e fix(tools): an allowed widget whose tables are not declared is not rendered; the person must be able to read them
render_widget rendered a widget that was allowed by name and had no
withWidgetTables entry without any check of what it reads. It now fails
closed: a widget is rendered only when it is allowed, its tables are
declared, and every one of them may be read by the assistant and by the
signed-in person (asked of the application as them).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 13:27:49 -06:00
james.maesandClaude Fable 5.2 f4b279b95d fix(tools): a tool call does not hold a monitor while it waits for another thread
maven / build (push) Successful in 9m40s
build / maven (push) Successful in 9m40s
A tool call is a virtual thread, and the first call of a turn works out what
the person is offered by waiting for another one. ToolCallService did that
inside synchronized(admission), which keeps the carrier thread: with two
processors a batch of tool calls, and with one processor every first tool
call of a turn, waited out toolCallTimeoutSeconds, and the person was then
offered no write and no process tool for that turn.

An admission is now guarded by a ReentrantLock. FewProcessorsTest runs in
JVMs with one and with two processors (two surefire executions) and fails
there without the fix.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-17 13:26:08 -06:00
james.maesandClaude Fable 5.2 18e893b835 fix(process): a card shows all a screen says; a screen that says more than a card shows is not passed
maven / build (push) Successful in 9m20s
build / maven (push) Successful in 9m20s
The first card showed the first 300 characters of a screen's text and then
passed the screen. It now shows the whole text (up to 2,000 characters), and
a screen whose text is longer is one the card did not show in full: the run
stops there.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-15 05:42:27 -06:00
james.maes d6bfe77c78 Merge branch 'fix/render-widget-follows-data-access' into feat/one-card-for-a-set
# Conflicts:
#	CHANGELOG.md
#	UPGRADE.md
2026-11-15 05:31:32 -06:00
james.maesandClaude Fable 5.2 50845aa99b fix(tools): render_widget follows the assistant's data access; no widget is rendered until a host allows it
maven / build (push) Successful in 8m50s
build / maven (push) Successful in 8m56s
A widget is code of the application and can show rows of any table, so
render_widget could hand a model the rows of a table the assistant may not
read. The tool now refuses, before the application is asked, every widget
the host did not allow by name (withAllowedWidgetNames, empty by default),
one it hid, and one that reads a table the assistant may not read
(new: withWidgetTables).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-15 05:30:57 -06:00
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
james.maesandClaude Fable 5.2 583f8f1f9d test: the existing security tests follow 'no card for what cannot happen'
A person the application refuses is refused before a card where the
application says so beforehand; the confirm-time refusal (a permission that
goes between the card and the confirmation) keeps its tests, with the UI's
own status and message. The tool-set file changes in one description
(run_process), replaced as text.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-15 05:23:13 -06:00
james.maesandClaude Fable 5.2 11fc143e6d feat(process): one confirmation runs a set to its end, within what its card showed; no card for a change the person may not make
A confirmed run_process goes through the process's own init and step
operations as the person and passes a screen for them only when it shows
nothing their card did not: its text and inputs were on the card with the
values the process has now, and a review counts exactly the records of the
card and, with every record validated first, has no warning and no error.
Anything else comes back to the person with a new card and nothing stored.

The set is frozen by primary key and by one digest over its records as the
person read them; a set that changed is not run. The card keeps what the
records were (how many, a sample of 20) and lists the whole set by name.

The assistant no longer creates a job: when the application itself hands the
work to a background job, the job is the person's, it is waited for, and its
outcome (rows done, failed and why) is the card's. A job the application
created waiting is cancelled and the run reported as not done.

A change to records of a table is proposed only to a person the application
lets make it (what it tells their own screens); otherwise they are told so
and there is no card.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-15 05:09:34 -06:00
james.maesandClaude Fable 5.2 a9ebe64883 fix(process): only a reviewed process runs; a person confirms what they were shown; an independent review of the process tools closed
maven / build (push) Successful in 7m48s
build / maven (push) Successful in 7m48s
After an independent review of the process tools. Each change is described
by the guarantee it gives.

- Only a reviewed process runs, decided when the application runs. A host
  registers the processes it reviewed for the assistant in
  AssistantQBitConfig (withReviewedProcesses, or
  withReviewedProcessesResource for a file on its classpath). With no list,
  only a table's own bulk edit and bulk delete are runnable: 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. RunnableProcessReview stays as the
  way a host notices drift in its build, and now also fails when the
  reviewed file 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 never an input
  (ProcessControlNames: the inputs of the process's backend steps, and a
  fixed set this QBit owns, checked by a test against the QQQ version it
  builds with). The person is told the field cannot be set through the
  assistant; the process stays runnable for its other fields.
- A person confirms what they were shown. A run stops at every later screen
  that has something to show (a form, values to read, a text, a list of
  records), and going on is a second card that shows it. Only a screen with
  nothing to show is passed. The screen a run starts at is on the first
  card.
- A run is over exactly the records its card counted. A filter is resolved
  when the run is proposed, to at most 500 primary keys (more is refused,
  for the person to narrow); the confirmed run is sent those keys and does
  not start when one of them is gone.
- A process that may run as a durable job is created waiting, or not run:
  where the application does not offer the operation that creates a job,
  the run is refused.
- Text of the application reaches a model only inside the data envelope
  every tool result uses: 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, for the summary a later request keeps of a
  process step, for what a later request is told became of a confirmed run,
  and for the thread's own message about it (ToolLabels.forModel,
  MessageParts.modelText).
- A card goes on only with the run as it stood when the card was made: a
  run counts a version up at every step and stop, and an older card of the
  same run is refused.

One expectation of ChatToolSetTest changes: the scenario
everythingAsAnotherPerson no longer holds the four process tools. That host
registered no reviewed list, and its person may run processes of another
QBit and change no table, so the assistant runs no process for them.
ToolCallChecksTest is unchanged. No new tool. AssistantStore is still the
only code that calls data actions.

README, UPGRADE.md, CHANGELOG.md, CLAUDE.md and section 4.5 of
docs/actions-and-mcp.md say the same.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 17:51:29 -06:00
james.maesandClaude Fable 5.2 7b4a2b9353 feat(process): the assistant runs a process the signed-in person may run, confirmed on a card; fix: four review findings
maven / build (push) Failing after 12m50s
build / maven (push) Failing after 12m50s
Process tools (package A4 of docs/actions-and-mcp.md), in tools/process:
list_processes, describe_process, run_process and get_run_status.

- The list and the description come from the person's own metadata, asked
  as them: a process they may not run is never listed or described, and is
  refused by name in the words used for a process that does not exist.
- run_process only proposes. Inputs are checked against the fields the
  process's screens declare before a card exists (unknown input, wrong
  type, missing required; no value is made up). The card (pending action
  kind process_run) shows the process, every input, the records and the
  steps that stop for the person.
- The confirmed run is the person's: it runs through the UI API with the
  confirming request's session, and a run whose records are no longer the
  ones the card counted does not start.
- A process eligible to run as a durable job is created as one and never
  started by the assistant; any other runs through its own init and step
  operations until it ends or needs the person (a review, a required field
  with no value), where going on takes a new card.
- A confirmed run never holds its pending action RUNNING: the action ends
  when the run was started, and get_run_status reports where it stands.
- What is never runnable through the assistant is decided in one place
  (ProcessRunnability): denied to the assistant channel, the assistant's
  own, data access not READ_WRITE, hidden, offered by no screen, on a table
  the assistant may not change, or with a screen it cannot present.

Review findings, by the guarantee each gives:
- A host notices each process that becomes runnable through the assistant:
  RunnableProcessReview fails the host's build when the runnable list
  differs from its committed file.
- An administrator is warned before the data-access migration opens a
  table they left read-only: UPGRADE.md has a query with the migration's
  own predicate, tested against the changeset.
- No tool says confirmation can be turned off (the cached request prefix
  changes once).
- No model is called without a spending limit in force: the routing
  classifier asks for its own model. The administrator's Test connection
  is the one documented exemption.

Also: a scheduled task is offered run_process only with its write
approval; a test that a confirmed update into a record-security key the
person lacks is refused by the application and changes nothing; UI API
extension assistant 1.10.0 (additive).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 15:04:09 -06:00
james.maesandClaude Fable 5.2 cc5fe2a700 feat(access): writes follow the signed-in person; no answer without a spending limit; fix: a fourth review of the tool boundary
maven / build (push) Successful in 7m33s
build / maven (push) Successful in 7m33s
Package A2 of the actions design (docs/actions-and-mcp.md, sections 2 and 3),
with two owner decisions of 2026-11-12, and five findings of an independent
review of the tool boundary, each closed by the guarantee it gives.

Writes follow the person
- The data access of a table or process is declared in versioned code:
  AssistantQBitConfig.withDefaultTableAccess / withDefaultProcessAccess (both
  READ_WRITE) and a pin per object (withTableAccess, withProcessAccess).
  READ_WRITE grants nothing: the assistant may propose what the signed-in
  person may do themselves, and every change waits for their confirmation.
- An administrator's assistant_data_access row can only narrow (READ, NONE).
  It never raises a code default, a pin or a table kept from AI.
- Every assistant_* table and every process of the QBit is NONE by a pin in
  code that no row and no host pin lifts.
- The write tools are offered to a person who may create, edit or delete
  records of some table (asked of the UI API as that person, once per offer,
  within the tool-call time limit; no answer means no write tool). GET /config
  features.writes is that answer for the person.
- Settings that cannot be read, and were never read, allow nothing.
- The table action "Add rows for every table" is retired. The changeset
  assistant-data-access-follow-user removes the unedited READ rows it wrote,
  and no other row.

No answer without a spending limit
- A person for whom no spending limit is in force (BudgetService.limitInForce)
  is refused: the turn before anything is stored, every model call, every tool
  call, every embedding request, a scheduled turn. Restoring a limit restores
  service on the next request.

Review findings
- A pending action is never marked expired over its outcome: expiry is a
  decision made through the same claim as confirming and cancelling.
- No action stays RUNNING for ever: retention ends one left running for more
  than an hour as FAILED ("outcome unknown, check the record"), with a log row.
- A person is the session the authentication module resolved, not the object
  passed in: a hand-made permission gives nothing, a revoked one is gone.
- The assistant's own reads get their context from the tool-call service, for
  a person it checked; there is no public way to make a tool context from a
  session id, a gateway and a policy.
- The published test-jar holds the testing package only.
- AssistantStore's decision methods are final.

See CHANGELOG.md and UPGRADE.md (what a host must apply before deploying).

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 13:11:20 -06:00
james.maesandClaude Fable 5.2 0dc325cd2c fix(tools): one decision per pending action, a tool surface closed at compile time; feat: pending actions with before and after
maven / build (push) Successful in 6m19s
build / maven (push) Successful in 6m19s
Closes the findings of a third independent review of the tool boundary and
builds the pending-action package of the actions design on top.

Guarantees:
- A pending action is confirmed or cancelled once, by exactly one request,
  on one server or several: the decision is an insert under a unique key
  (new table assistant_pending_action_claim). Whatever fails after the claim
  ends in FAILED or EXECUTED with a tool-call row, never in RUNNING.
- A tool cannot be run around the tool-call service from code outside the
  assistant's packages: execute, log and withdraw are package-private; a
  tool call request, a confirmed tool call and a tool context have no public
  constructor and are made only with the service's permit; the runtime has
  no public getter for the tool registry, the UI API gateway or its tool
  families. A host's own ToolFamily and AssistantTool compile unchanged.
- A signed-in person is one person: a session with no HTTP request is made a
  person only when the authentication module resolves the session's own id
  to the user the session names. The turn engine no longer makes a person.
- Only the credential a request's session was resolved from is forwarded to
  the UI API.
- A tool call that was cut short leaves no proposal anybody could confirm.
- The policy a tool call runs under is read fresh on every call.
- The hard budget is read on every call with one aggregate query per budget.
- The input kept in the tool-call log is redacted with the administrator's
  custom patterns too.

Pending actions (design package A3):
- update_record and delete_record read the record as the person when they
  propose; the card shows each field before and after (a delete: what the
  record holds), after the exposure rules of get_record.
- What was approved is what is written: the proposal keeps a version of the
  record (a digest, never values); a confirmed update or delete reads the
  record again and refuses when it changed, is gone or cannot be read.
- actionKind (record_create, record_update, record_delete, or the proposing
  tool's name), GET /assistant/actions (the person's own list), and
  approvalRetentionDays is now read by the retention process.
- UI API extension assistant 1.9.0 (additive).

Schema: three columns and two indexes on assistant_pending_action, and the
table assistant_pending_action_claim (docs/schema-postgres.sql, UPGRADE.md).

ChatToolSetTest and ToolCallChecksTest pass unchanged.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 11:35:43 -06:00
james.maesandClaude Fable 5.2 7c9176fcc8 fix(tools): the tool-call service owns the policy, the identity and the confirmation
maven / build (push) Successful in 6m51s
build / maven (push) Successful in 6m51s
An independent security review of engine.ToolCallService (after PR 106)
found what a caller could still hand it. The chat's turn engine is the
only caller today and builds everything correctly, so none of it was
reachable; it is closed before an MCP endpoint calls the service. The
rule: every tool call runs as the signed-in person with their current
permissions and budget, never as the assistant; a refusal happens before
any data action; every call that ran has a log row with redacted input.

Numbered as in the review:

 1. A caller cannot supply a policy. The service reads it
    (PolicyService.current(false).tools(), narrowed for a scheduled
    task's conversation) and builds the tool Context itself; a caller
    hands it a tools.registry.ToolCall (person, id, name, input).
    Every change always shows a confirmation card (owner, 2026-11-12):
    ToolPolicy.writesRequireConfirmation is removed and UiApiToolbox
    always proposes. The assistant_policy column stays and is no longer
    read; no migration.
 2. New SignedInPerson binds a session to the credentials forwarded to
    the UI API. No public constructor: ofRequest(Context), only for
    AssistantSpecs (ArchUnit), or ofSession(session). The context's
    gateway is always runtime.getUiApiGateway(). AssistantApi and
    TurnEngine lose withCredentials.
 3. The hard budget is read on every call, not once per scope.
    executeAndLog(call, conversationId, hipaaRoute) makes the scope.
 4. confirm(person, pendingActionId) replaces executeConfirmed,
    confirmationRefusal and logConfirmed: the service loads the stored
    action of that person, checks it, claims it once, runs it, marks it
    and writes the row. AssistantApi.confirmAction is a thin caller and
    the only one (ArchUnit).
 5. The toolboxes cannot be called around the service: their entry
    points are package-private, the runtime has no getter for a toolbox
    (each family is handed its own), and ArchUnit forbids calls into
    tools.. from outside it except through the registry. The assistant's
    own reads (starter prompts, knowledge re-read) use the new read-only
    UiApiToolbox.read.
 6. TurnEngine.executeTools writes each started call's row in a per-call
    finally: after an interruption of the engine, after a runtime
    exception while a result is processed or logged, and for a call cut
    short by its time limit, with the real outcome when the worker
    finished. A row that cannot be written for a call that changed data
    is logged at ERROR.
 7. Whatever fails after a confirmation's claim ends in FAILED with a
    row, never in RUNNING.
 8. The service checks that the scope's conversation and turn belong to
    the call's person and works out the row's client channel itself
    (ToolCallScope.clientChannel is gone). hipaaRoute stays the
    caller's; the javadoc says why.
 9. AssistantQBitConfig.withToolFamily throws once the QBit is produced.

Tests: ToolCallServiceTest (one per item, on the service directly),
ToolCallRowsTest (item 6; all three fail on develop), and
ToolCallArchitectureTest (items 2, 4, 5). ChatToolSetTest and
ToolCallChecksTest pass with unchanged expectations.
UiApiToolsSecurityTest's two tests that ran writes with confirmation off
now propose and confirm.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 10:37:13 -06:00
james.maesandClaude Fable 5.2 d42c536dcf fix(tools): the tool-call service makes its own checks, for any caller
maven / build (push) Successful in 6m45s
build / maven (push) Successful in 6m45s
engine.ToolCallService trusted its caller for several checks. The chat's
turn engine made them around the service; a caller with no chat turn (an
MCP endpoint, later) would have skipped them. The rule that now holds for
any caller: a tool call runs as the signed-in person with their current
permissions and budget, a refusal happens before any data action, and the
call is logged with redacted input.

 1. execute refuses a tool the person is not offered now. It builds the
    offer from the request's policy and session (once per scope). Before,
    only the turn engine's allowed-tools set did, and navigate and
    search_help ran although the policy had switched them off.
 2. A request without a policy is refused. UiApiToolbox, KnowledgeTool
    and BulkLoadTools read a missing policy as "every tool"; they refuse.
 3. A request whose context was made for another session than its own is
    refused, for a call and for a confirmation. ConfirmedToolCall carries
    the confirming session.
 4. New executeAndLog: runs the call and writes the assistant_tool_call
    row, redacting the input itself, also for a refused call. Redaction
    and the row moved out of TurnEngine (redactInput is gone; what a
    presentation logs is AssistantTool.inputForLog). The turn engine runs
    its calls in parallel under its own time limit and writes rows in
    call order, so it uses the two halves, execute and
    log(request, outcome); an ArchUnit rule keeps every other class on
    executeAndLog. The chat's rows are unchanged.
 5. The service's javadoc says what it enforces and what a caller still
    supplies (rate limiting, per-request call limits and timeouts,
    classification).
 6. The confirm route refuses while the kill switch is on (503
    KILL_SWITCH) and when the policy no longer allows the tool (403),
    before the pending action is claimed, so it stays pending.
 7. Tool families are registered explicitly: the QBit's own list
    (AssistantRuntime.ownToolFamilies) plus
    AssistantQBitConfig.withToolFamily for a host or another QBit. The
    classpath scan is gone. The registered names are logged once at
    startup; a duplicate name or an empty registry stops the start.
 8. ToolRegistry.definitions sorts the keys of every object of an input
    schema, so two JVMs send the same bytes (a Map.of schema iterated in
    a per-JVM order, and the provider mappings serialise in iteration
    order).
 9. The service itself requires assistant access, checks the kill switch
    (fresh) and the hard budget (the policy's hard limits and a stopped
    budget row, read without a budget event or alert, when a scope's
    first call arrives). New BudgetService.stoppedReason.

Tests: ToolCallServiceTest (fixes 1 to 4, 6, 9, called with no turn),
ToolRegistryTest (7, 8), ToolCallArchitectureTest (the new rule).
ChatToolSetTest and ToolCallChecksTest pass unchanged. Test helpers that
handed a tool a null policy now hand it the defaults.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 09:46:52 -06:00
james.maesandClaude Fable 5.2 f035d6356b refactor(tools): one tool registry, no behaviour change
maven / build (push) Successful in 5m45s
build / maven (push) Successful in 5m45s
Every tool is registered once in tools.registry.ToolRegistry: its name, its
kind (READ, PROPOSE, DISPLAY), the checks it runs, its definition and how one
call of it runs. The chat's tool list, a tool call of a turn and a confirmed
write all look a tool up there; the turn engine and the confirm route no
longer choose a tool family with an if-chain.

"Run one tool call for this person under this policy, and log it" moves
out of TurnEngine into engine.ToolCallService, which the confirm route uses
too: the refusal of a tool that is not offered, the call (with the person's
own session) and the assistant_tool_call row.

What moved where:
 - ContextBuilder.tools: the per-family blocks become
   ToolRegistry.definitions(ToolOffer); each family's block is its
   AssistantTool.definition (UiApiToolFamily, engine.KernelToolFamily,
   KnowledgeToolFamily, PresentResultsToolFamily, BulkLoadToolFamily).
   isStrict moves to ToolRegistry.isStrict.
 - TurnEngine.executeTools: the 'Unknown tool' refusal is
   ToolCallService.refusal; the dispatch is ToolCallService.execute; each
   branch is its family's AssistantTool.execute (the data families keep the
   QContext init and clear around the call; the presenter stays one per turn
   through ToolCallScope.state).
 - TurnEngine.recordToolResult: the row is built by ToolCallService.log; the
   bulk-load log reduction and search_knowledge's operation are the tools'
   forLog and operationWithoutDetail.
 - AssistantApi.confirmAction: the if-chain is
   ToolCallService.executeConfirmed; the row is ToolCallService.logConfirmed.

UiApiToolbox, AnalysisTools, BulkLoadTools, KnowledgeTool, PresentResultsTool
and the core kernel keep all of their behaviour. A tool family is a class
under com.kingsrook.qbits.assistant.tools that implements ToolFamily; it is
found at startup, so a new family is new files only. The kernel family lives
in engine and is named by the runtime, because nothing under tools may touch
the kernel (ArchitectureTest).

Tests: ChatToolSetTest compares the chat's tool list (names, order,
descriptions, schemas, strict flags, in six scenarios) with the list written
from origin/develop at e02658d before any production code changed.
ToolCallChecksTest (permission, tool switch, data access, the person's own
request, confirmation, and the log row of each refusal) passes unchanged on
the code before and after. ToolRegistryTest and ToolCallArchitectureTest cover
the registry and bind 'only ToolCallService runs or logs a tool call'. No
existing test changed.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 17:57:16 -06:00
james.maesandClaude Fable 5.2 6cbd530719 fix(store): the assistant works for people who do not administer it where core enforces table permissions
maven / build (push) Successful in 4m54s
build / maven (push) Successful in 4m54s
On a host with QInstance.enforcePermissionsInCoreActions on, a person with
assistant.hasAccess and without assistant.admin was refused before any model
call ("Not authorized to access the assistant admin data."). The assistant
reads its settings (policy, providers, models, prices, budgets, data access)
and writes that person's messages, turns, tool calls, pending actions and
usage through tables whose permission rule is assistant.admin, with the
person's session. On a host without core enforcement nothing checked that
rule for the store, so it was never seen.

AssistantStore, the only package allowed to call QQQ data actions, now marks
every one of its calls as the assistant's own service code
(withPermissionBypass with a reason), the way qbit-collaboration and
qbit-backups do. Only the table permission check is skipped, for those calls:

 - the session stays the person's: writes are attributed to them, and the
   owner record locks keep every other person's rows out (core does not relax
   record locks for a bypass);
 - the tables' permission rules are unchanged: the tables stay closed to that
   person in the UI, the UI API and the assistant's tools;
 - who may call is decided before the store: every operation of the assistant
   API requires assistant access, and the save rules of budgets and overrides
   require assistant.admin themselves.

A person's own budget. GET /config has "budgets" (UI API extension assistant
1.8.0): the budgets scoped to that user or to a permission that user holds,
with used, limit, percent, state and when the count starts again. Budgets
shared by several people are not listed. The same lines ride beside the
person's question (<assistant_budget>), so "how much of my budget have I
used?" has an answer.

CoreEnforcementTest runs on the fixture instance with core enforcement on.
Run without the store change, four of its five tests failed at the first
store read; the fifth (own budget) was written afterwards.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 11:04:09 -06:00
james.maesandClaude Fable 5.2 48cca86285 feat(budgets): weekly budgets, a refusal that names the limit, a ceiling on what may be saved
maven / build (push) Successful in 4m52s
build / maven (push) Successful in 4m52s
A budget (Assistant > Budgets) can count over a WEEK: the ISO week in UTC,
Monday 00:00:00 UTC up to the next Monday 00:00:00 UTC. DAY and MONTH are
unchanged and there is no schema change (period is text).

The refusal at a limit now says which limit, how much, when the count starts
again and who can change it: "The assistant has reached the weekly limit of
$500.00 of the budget 'Everyone, a week'. It starts again on Monday 19 October
2026 at 00:00 UTC. An administrator can raise the limit or grant an override."
The warning says "weekly" for a weekly budget.

New config budgetCostLimitCeilingUsd (default 1,000,000, null for none): a
cost budget above it is refused when saved. A budget is created or changed
only by a session that holds assistant.admin; the save rule now checks it as
it already did for overrides, besides the table's permission rules.

Budgets are read from their table at every evaluation and are not cached, so
a changed limit applies to the next question. That was already so; it is now
stated and tested.

Tests (BudgetServiceTest): the week boundary in UTC, including a Sunday
evening in Chicago that is Monday in UTC and a week across a year end; the
micro-USD to dollar conversion at the limit (499,999,999 micros warn, one more
refuses); the refusal sentence and HTTP 429 BUDGET for a new question; a
changed limit taking effect on the running service; the ceiling; and a person
without assistant.admin refused by the table's permission and by the save.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 10:00:13 -06:00
james.maesandClaude Fable 5.2 7c54a02a87 feat(tools): save and schedule an analysis with one confirmation; decided actions reach the conversation; ask before guessing
maven / build (push) Successful in 6m31s
build / maven (push) Successful in 6m31s
save_analysis proposes keeping an analyze_records question as a saved analysis the user owns
and, when asked, a daily schedule emailed to them. One pending action lists everything that
will be created with the numbers as they are now; nothing exists until the user confirms it
(never auto-confirmed). On confirmation both records are created through the data-analysis
tables' own insert operations with the confirming user's session. Offered only with the
data-analysis extension and data access READ_WRITE on data_analysis_saved (a schedule also
needs it on data_analysis_schedule); the user's own insert permission is read from
GET /metaData first.

A schedule that could never run is refused when proposed and again at confirmation, with
what is missing: the instance is read (a schedule table, a scheduler on
data_analysis_run_schedules) and the host is asked through
AssistantQBitConfig.withScheduledDeliveryCheck.

Confirming any pending action now adds a message of the assistant to the conversation
(what was done, links to the records), and each earlier proposal carries what became of it
in the next request (done, failed, cancelled, expired). Before, the model only ever saw
'waiting for confirmation'.

Rule 14 for every model: ask one short question when a request is ambiguous in a way that
changes the result (table, field, time zone); the user's browser time zone is stated in the
per-user context. Golden task clarify-ambiguous-field.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 07:34:51 -06:00
james.maesandClaude Fable 5.2 10d80f6bcf test(tools): run the analysis tests against data-analysis 0.3.0-RC.2 (relative dates in filters)
maven / build (push) Successful in 5m17s
build / maven (push) Successful in 5m17s
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 07:27:31 -06:00
james.maesandClaude Fable 5.2 ad33fbcf4f fix(tools): an extension tool's operation is not a core operation
OPERATIONS stays the list of core /qqq/v1 operations (every one is invocable on any
instance); analyze_records moves to EXTENSION_OPERATIONS, offered and invocable only where
the data-analysis extension is registered. A test pins that it is neither offered nor
invocable without the extension.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 07:11:33 -06:00
james.maesandClaude Fable 5.2 e634d6a192 feat(tools): analyze_records answers grouped questions through the data-analysis pivot
A new read tool: group a table by one or two fields (a date field optionally by a calendar
unit) and compute a count, sum, average, minimum, maximum or distinct count per group, with
the usual filter. It is one call of the data-analysis qbit's pivot operation
(POST /qbit/data-analysis/tables/{table}/pivot) through the same gateway and with the
signed-in user's session, so table read, the table's analyze permission, field access and
record locks decide as on the Analyses screens. The assistant only narrows it: data access
READ on the table, fields whose values it may see, the policy's row cap. Offered only where
the data-analysis extension is registered; no production dependency on that qbit.

Tests run against the released data-analysis qbit served by the real UI API.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 07:06:27 -06:00
james.maesandClaude Sonnet 5.5 0c32c43f8c fix(engine): a stalled database can no longer hang a turn on 'Thinking'
maven / build (push) Successful in 5m23s
build / maven (push) Successful in 5m23s
The watchdog ran the deadline logic after two database reads and heartbeat() was synchronized on the monitor that finish() needs, so one blocked database call stopped the deadline, the force-finalize and the final message.end. The deadline now runs first with no database access, housekeeping runs on a bounded abandonable worker, finish() has a guard that ends the stream with an error event, and every phase logs at INFO.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-09 09:54:50 -06:00
james.maesandClaude Sonnet 5.5 a588aafe2e test(assistant): pin the live thread to real title, question, answer and tool steps at message.end
maven / build (push) Successful in 4m29s
build / maven (push) Successful in 4m29s
The panel reloads the conversation at message.end. A tool-using turn must
already have stored the real title, the question and answer parts and the
tool-call rows then, not the transcript redactor's placeholders
(changed:v1, [], {}). The redactor is always attached to a turn, so this is
independent of Secured Data. Fails without the flush-before-message.end
ordering (RC.24), passes on develop and RC.25.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-08 19:46:55 -06:00
james.maesandClaude Sonnet 5.5 3539f5fd93 fix(assistant): store the transcript before message.end so the panel shows the answer
QRun-IO/ci-policy: ci / fork-guard (pull_request) Skipped
QRun-IO/ci-policy: ci / head-profile (pull_request) Skipped
QRun-IO/ci-policy: ci / application-template-0 (pull_request) Skipped
QRun-IO/ci-policy: ci / gradle-1 (pull_request) Skipped
QRun-IO/ci-policy: ci / java-docker-4 (pull_request) Skipped
QRun-IO/ci-policy: ci / java-frontend-browser-5 (pull_request) Skipped
QRun-IO/ci-policy: ci / java-maven-6 (pull_request) Skipped
QRun-IO/ci-policy: ci / node-8 (pull_request) Skipped
QRun-IO/ci-policy: ci / java-maven-7 (pull_request) Skipped
QRun-IO/ci-policy: ci / node-9 (pull_request) Skipped
QRun-IO/ci-policy: ci / node-10 (pull_request) Skipped
QRun-IO/ci-policy: ci / node-playwright-11 (pull_request) Skipped
QRun-IO/ci-policy: ci / repository-policy-12 (pull_request) Skipped
QRun-IO/ci-policy: ci / source-config-13 (pull_request) Skipped
QRun-IO/ci-policy: ci / source-config-14 (pull_request) Skipped
QRun-IO/ci-policy: ci / android-0 (pull_request) Skipped
QRun-IO/ci-policy: ci / original-business (pull_request) Skipped
QRun-IO/ci-policy: ci / original-mcp (pull_request) Skipped
QRun-IO/ci-policy: ci / original-voyage (pull_request) Skipped
QRun-IO/ci-policy: ci / original-cli (pull_request) Skipped
QRun-IO/ci-policy: ci / not-enrolled (pull_request) Skipped
QRun-IO/ci-policy: native / fork-deny (pull_request) Skipped
QRun-IO/ci-policy: native / dotnet-0 (pull_request) Skipped
Shared Java Maven CI with Docker / secrets (push) Successful in 32s
QRun-IO/ci-policy: native / native-result (pull_request) Successful in 11s
QRun-IO/ci-policy: Shared Java Maven CI with Docker / secrets (pull_request) Successful in 31s
QRun-IO/ci-policy: ci / repository-policy (pull_request) Skipped
QRun-IO/ci-policy: ci / java-core-2-head (pull_request) Skipped
QRun-IO/ci-policy: ci / java-docker-3-head (pull_request) Skipped
QRun-IO/ci-policy: ci / java-maven-6-head (pull_request) Skipped
QRun-IO/ci-policy: ci / java-maven-7-head (pull_request) Skipped
Shared Java Maven CI with Docker / verify (push) Successful in 7m47s
QRun-IO/ci-policy: Shared Java Maven CI with Docker / verify (pull_request) Successful in 6m48s
Shared Java Maven CI with Docker / gate (push) Successful in 27s
qrun-release / release (push) Successful in 12m20s
qrun-release / postpublish (push) Skipped
QRun-IO/ci-policy: Shared Java Maven CI with Docker / gate (pull_request) Successful in 20s
QRun-IO/ci-policy: ci / java-docker-3 (pull_request) Successful in 14m14s
QRun-IO/ci-policy: ci / ci-result (pull_request) Successful in 8s
Release candidate / release-rc (pull_request) Skipped
The panel reloads the conversation the moment the stream ends. The
redacted transcript (message parts, pending actions, stored events) was
flushed only after message.end was sent, so that reload read the "[]"
placeholders and showed the newest question and answer as empty bubbles
until the panel was closed and reopened. Persist and flush first, then
emit message.end.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 19:16:11 -06:00
james.maesandClaude Fable 5.1 ca9212731d fix(api): say NOT_CONFIGURED, with what to configure, when no model provider is usable (#83)
QRun-IO/ci-policy: ci / not-enrolled (push) Skipped
QRun-IO/ci-policy: ci / fork-guard (push) Skipped
QRun-IO/ci-policy: ci / gradle-0 (push) Skipped
QRun-IO/ci-policy: ci / java-maven-2 (push) Skipped
QRun-IO/ci-policy: ci / node-3 (push) Skipped
QRun-IO/ci-policy: ci / node-4 (push) Skipped
QRun-IO/ci-policy: ci / source-config-5 (push) Skipped
QBit CodeQL / Analyze branch source (push) Canceled after 0s
CodeQL / analyze (push) Canceled after 0s
QRun-IO/ci-policy: Shared Java Maven CI with Docker / verify (push) Successful in 7m45s
QRun-IO/ci-policy: Shared Java Maven CI with Docker / secrets (push) Failing after 21s
QRun-IO/ci-policy: Shared Java Maven CI with Docker / gate (push) Failing after 8s
QRun-IO/ci-policy: ci / java-docker-1 (push) Failing after 37m15s
QRun-IO/ci-policy: ci / ci-result (push) Failing after 5s
The probe reports DISABLED, NOT_CONFIGURED, NO_PERMISSION, KILL_SWITCH in that order; GET /config gains an additive message naming what to configure; a user without access on an unconfigured server gets 503 NOT_CONFIGURED instead of 403. Extension 1.7.0.

Fixes #82

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-11-01 11:30:04 -06:00
james.maesandCodex 3637ca3ad0 fix: integrate conversation management with current develop
Preserve current attachment, notification and starter prompt behavior. Encrypt user titles that resemble ciphertext unless they match the same stored record; verify all eight reactor modules.

Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 09:52:41 -05:00
james.maesandCodex a353381d02 Merge develop into feature/starter-prompts-from-access
Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 09:20:00 -05:00
james.maesandCodex b250585dde fix(assistant): recheck starter prompt access on every request
Cap combined prompts at three and remove cached authorization-sensitive suggestions. Preserve bounded deterministic generation and cover field, row, table, policy and history changes. Thirty focused tests passed.

Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 08:50:26 -05:00
james.maesandCodex 407bdcdb47 fix(tools): read the flat v1 table metadata response
Preserve field visibility filtering while interpreting the actual API response shape. Verified allowed fields and hidden/password exclusions through the real endpoint.

Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 08:50:25 -05:00
james.maesandCodex 3db34201fc merge: integrate verified assistant attachment support
Preserve both attachment and notification behavior. Full eight-module verify and 45 focused turn, notification, bulk-load and attachment tests passed.

Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 08:36:30 -05:00
james.maesandCodex 9adc28f0d9 fix(attachments): validate image data and preserve host PDF fonts
Decode images within frame and pixel limits before provider use, contain malformed attachments per file, and preserve the host PDFBox font mapper.

Co-Authored-By: Codex <noreply@openai.com>
Signed-off-by: James Maes <james@kof22.com>
2026-10-19 07:50:25 -05:00
james.maesandClaude Opus 5.5 de36dbaf8d feat(assistant): give attached files to the model as untrusted data
The turn engine reads pageContext.attachments through AttachmentService and
inlines the framed content (and images for vision models) into the
question's user message, after both cached system blocks. Unreadable files
become notices; image parts are dropped before a call to a model without
vision. In HIPAA mode attachments count as PHI. The system prompt treats
uploaded_file blocks as data and tells the model to propose writes with
create_record/update_record instead of saying it cannot create records.
GET /config reports features.attachments and the attachment limits.
Adds end-to-end, PHI routing and red-team tests.

Part of KofTwentyTwo/Website-Backend#305

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:51:43 -05:00
james.maesandClaude Opus 5.5 b5cd747899 feat(assistant): users manage their own conversations in the table UI
assistant_conversation is open to every assistant user (assistant.hasAccess
or assistant.admin) through AssistantAccessPermissionChecker; rows stay
locked to their owner, and the Assistant app and other tables stay
admin-only. A conversation customizer limits user edits to title, pinned
and status, refuses deleting a conversation with an answer in progress and
deletes the child rows after a table delete, through the same store code
as DELETE /conversations/{id}.

Adds Archive, Restore and Delete conversations as standard streamed-ETL
record actions on the table, acting only on rows the user can see.

UI API extension assistant 1.6.0: conversation list items have running,
PATCH /conversations/{id} accepts {"read": true}, and GET /config has
conversationsTable when the session may query that table.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:46:06 -05:00
james.maesandClaude Opus 5.5 c2023aa63f feat(assistant): read attached files safely (sniffing, caps, PDF text, table previews, images)
Adds the attachments package: uploads are read as the signed-in user's own
upload (core UploadRefs plus an owner check) into memory with byte caps;
the type is sniffed from content; executables, archives and unknown binary
data are refused; text and JSON are decoded with charset detection; PDF
page text comes from PDFBox (already on the classpath through core) with
page, character and memory caps and no font scan; CSV and XLSX previews
reuse core's bulk-load parsers; image sizes are read from headers.
Content is framed as an untrusted uploaded_file block with neutralized
delimiters. Limits live in AssistantQBitConfig.attachments.

Part of KofTwentyTwo/Website-Backend#305

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:43:10 -05:00
james.maesandClaude Opus 5.5 e4f369a4e7 feat(config): build starter prompts per user from what they can access
GET /assistant/config returned the profile's starter prompts as static
text, so a user could be offered examples about tables they cannot see.
profile.starterPrompts (same field and shape) is now built per user:
up to three prompts generated from the tables the user can read through
the assistant that have rows (list_tables, count_records and
describe_table via the UI API with the user's own session), cached five
minutes, stable for the day, bounded and fail-soft. Configured prompts
stay only when tagged with tables the user can read.

Part of KofTwentyTwo/Website-Backend#303

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:34:35 -05:00
james.maesandClaude Opus 5.5 e1f64cfa05 fix(assistant): send scheduled task notifications through core QAlerts
The notification a task owner asked for (output mode Notification or Both)
now goes through core QAlerts.notify: category Job, the owner as the only
audience, severity by run status and a link to the conversation. It replaces
a reflective call into an older alerts SPI that no longer matched.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:29:53 -05:00
james.maesandClaude Opus 5.5 f7235690b6 feat(assistant): link a launched bulk load to its job
A confirmed bulk load still launches a real durable job through
POST /qqq/v1/processes/{p}/jobs. Its tool result now carries jobHref (the
job's /app link) next to jobId and a record ref to the job, and the confirm
response's href points at the job, so the conversation links to it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:29:51 -05:00
james.maesandClaude Opus 5.5 ac2107bd97 feat(assistant)!: chat turns are not jobs; remove the run tracker SPI
Ordinary chat turns no longer create core tracking jobs, so they stay out
of the Jobs tray and tables and no longer trigger a per-answer "finished"
notification. Crash safety comes from the assistant's own turn table
(leased, heartbeated assistant_turn rows, seq-numbered event replay and the
abandoned-turn sweep), which is unchanged.

Removes AssistantRunTracker, JobTrackingRunTracker, the config accessors and
the tracking id on RunningTurn, with their tests. The panel's Stop
(POST /turns/{id}/cancel) is unchanged and still covered.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:29:48 -05:00
james.maesandClaude Opus 5.5 cfad90eaee fix(assistant): optional unreachable providers degrade health; add provider setup state
An enabled provider that is not the default and not the only route for any
configured routing (enabled profile simple/complex model, budget downgrade,
knowledge source embedding, with no fallback on another usable provider) is
optional. When it is unreachable its provider and model checks now report
DEGRADED with a message naming where requests go, instead of turning the
whole "assistant" component DOWN (central health rolls up worst-of; WARNING
severity does not cap DOWN). The default provider and sole routes stay DOWN.
Failed provider probes carry reachable=false so the circuit breaker still
refuses the provider when its central outcome is only DEGRADED.

New assistant_provider.setup_state (Active / Setting up, empty = Active):
a provider that is Setting up is never routed to (default, profile models,
fallbacks, budget downgrades, embeddings) and gets no provider or model
health checks. Additive guarded DDL in docs/schema-postgres.sql; see
UPGRADE.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:43:58 -05:00
james.maesandClaude Opus 5.5 f14e445e9c fix(assistant): worded health tile instead of the raw UNKNOWN enum
The Assistant health tile showed the HealthStatus name (UP/DEGRADED/DOWN/UNKNOWN). It now shows Healthy / Degraded / Down, and "Not checked yet" when no
check has reported, with the check cadence in the context line. The drill to health_check is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 09:13:32 -05:00
james.maesandClaude Opus 5.5 38ac805fe7 feat(assistant): POST /assistant/client-errors with the assistant_client_error table and health check
UI API extension assistant 1.5.0 adds POST /qqq/v1/assistant/client-errors
(AssistantClientErrorReportV1 in, AssistantClientErrorResponseV1 out, 202).
Any signed-in user may report; scope and message are required (400
otherwise, also for a non-object body). Every field is bounded, message and
stacks are scrubbed (AiRedactor secrets, e-mails, digit runs over 6, mixed
tokens, query strings), the route keeps only its path, and conversation /
message / turn ids are kept only when they are the user's own. Over
clientErrorsPerUserPerMinute (default 30) the report is acknowledged with
accepted:false and dropped, never a 429.

Rows go to the new owner-locked assistant_client_error table (Assistant app
nav, record screens, bundle help, channel wall by pattern, SET NULL foreign
keys in the reference DDL) and are deleted by retention after
toolResultRetentionDays. The assistant.client-errors health check is
DEGRADED at clientErrorWarnPerHour (default 20) reports in the last hour, so
the Assistant health card shows it too. The deprecated AssistantErrorV1
description again says "since 1.3.0".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 20:38:12 -05:00
james.maesandClaude Opus 5.5 20758cbc9b feat(assistant): tool and turn timeouts, failures as error parts, and turns that always end
- toolCallTimeoutSeconds (default 60): each tool call is bounded from when
  it gets a permit, and never outlives the turn's deadline; a timed-out call
  gets an ERROR is_error result.
- Tool exceptions (also Errors and toolbox failures) become an ERROR tool
  part plus an error notice; the details go only to the log.
- The engine checks renders and presentations (RenderShapes) before it
  emits or stores them; an undisplayable one is replaced by an error notice.
- Terminal events are emitted independently, so message.end and the
  terminal turn row are always written.
- Conversation detail repairs messages left STREAMING (reaping orphaned
  runs), and retention finalizes runs abandoned past the hard stream limit.
  The recovery writes are shared in AbandonedTurns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 20:20:44 -05:00
james.maesandClaude Opus 5.5 5180ef6102 feat(assistant): validate every part, render and presentation before it is stored or streamed
RenderShapes now checks all render types (records, record, count, widget,
history, pending_action, bulk_load_dry_run) and presentation blocks (table,
chart, metrics, filterLinks, recordLinks, actions): required lists are always
present, non-object entries are dropped and required strings get safe
defaults. A render that cannot be repaired is dropped and replaced by an
error notice ("This result could not be displayed."); unknown part and
render types pass through. Stored parts and replayed events are normalized
on read, so older rows are repaired too. Problems are logged with the type
and a fixed problem code only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 20:20:32 -05:00
james.maesandClaude Opus 5.5 8e473bcb56 fix(assistant): records renders keep empty lists; streamed progress keeps the turn context
A query that matched nothing produced a records render without rows or
columns: QQQ's JSON omits empty lists, and Next crashed reading
rows.length. Parts and stream events are now written keeping empty lists
(RenderShapes), stored ones are completed when read, and extension 1.4.0
documents AssistantRecordsRenderV1.

Streamed deltas arrive on the provider's virtual thread without a QContext,
so the writing-phase progress (JobLogWriter) failed with an NPE; the delta
handler now runs in the turn's captured context.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 19:37:19 -05:00
james.maes 4b7eb81d6d Merge remote-tracking branch 'origin/develop' into feature/ui-api-1.6 2026-10-15 16:01:07 -05:00