Inspect dashboards

Find app capabilities in the local and Cloud dashboards and interpret plugin inventory, metrics, standing observations, checks and agent tools.

The local dashboard and Cloud app inspector share the same task navigation and transport-independent pages. Choose an app first; Cloud keeps the selected environment when changing views.

Shared workspace design

Both dashboards use the same Signal masthead, Voltro wordmark and product badge, centered content width, workspace headings, app identity header, controls and light/dark theme tokens. The local dashboard opens with Overview at /; app selection lives at /apps. It exposes Overview, Apps, Logs, Metrics and Settings in its context navigation. Inside an app, a persistent sidebar lists every task by group; on smaller screens the Navigation button opens the same list. Charts use the Signal violet spectrum, with red reserved for errors. The request trend leads the overview; status shares and ranked endpoints supplement latency, error-rate and cache plots. Missing latency samples and undefined rates appear as gaps or “—”, never as measured zeroes. Empty plots wait for real stream events.

All 40 shared inspection areas have routes in both hosts. The local app overview adds the combined route/RPC/live-event summary. Cloud data branches depend on managed provisioning; organizations, membership, subscriptions and managed hosting remain Cloud functions. App-plugin billing inspection remains available locally when the billing plugin is installed. Plugin views stay listed even when the plugin is not installed; their availability is marked in the sidebar.

To build another workspace, import SignalWorkspace, SignalWorkspaceHeader, SignalWorkspaceItem and SignalHeader from @voltro/ui-shadcn, alongside its tokens.css and signal.css. Pass host-specific branding, navigation and utilities as slots; the shared shell owns the background and control styling. AppInspectorHeader from @voltro/devtools-ui supplies app identity above AppInspector. The host still owns routes, credentials, transport and environment selection.

Select replicas

Saved retry, restart and control requests belong to the inspected app and original run, not to a replica read selection. Their recovery panels remain accessible on the run detail page while the selected replica is loading, unavailable or cannot find the run. Switching replicas or reloading does not automatically resubmit the action. A different app or run does not display those saved requests; confirmation is recovered through their receipt readers.

Workflow run lists and statistics retain the last successful snapshot while the same selection refreshes or becomes unavailable. Separate notices identify loading, refreshes and stale data. A failed initial read is not empty run history. Current run summaries and attention indicators return only after their required reads succeed. Changing the app, replica selection or query clears the retained snapshot. Run counts and attention describe the loaded, filtered results; duration statistics and charts describe the selected time window and are not narrowed by source or status filters.

If the workflow admission read fails, its panel shows the load error instead of an admitting or paused status. Pause/resume controls return after a successful read; a cached snapshot is not treated as current admission health.

Changing replica selection keeps the current page's filters and URL fragment, including filters edited since the last navigation. Recovering from an unavailable replica does not silently reset the workflow view.

The API app header offers All replicas, any explicit subset, or a single replica. Apply the selection once; it remains in the URL across inspector views, table changes and record links. All replicas includes newly discovered processes. An explicit subset keeps its IDs while a process is unavailable — stale, without a reachable address, or expected by the fleet without an answer. A process that ended is no longer listed by the fleet and never answers again, so its ID is removed from the selection; the header names the removed IDs, and a selection left empty returns to All replicas.

Logs combine records with their replica of origin. Traces retain the origin of each span. Additive metric counters can be combined; compatible histogram buckets are merged before calculating quantiles. Precomputed percentile windows remain separate per replica, and incompatible histograms show an unavailable quantile. Other process observations are compared in separate replica sections rather than added together. Missing answers remain visible in the observation completeness.

Shared-store records have one table and one editor. Reads use one selected responder, trying another selected responder if necessary; an explicit singleton never silently falls back to another process. Writes execute once, without replica fan-out. The local dashboard combines shared-store change notifications from every known fleet member, even when reads use a single selected responder. New members are subscribed and departed members are removed as discovery updates. All these feeds use the same multiplexed browser connection. In contrast, process event streams connect to the specifically selected process. The local overview shows interruptions explicitly, retains that process’s last events during reconnect, and clears them when the selected process changes.

Plugin panels keep their selected installation and local action state through a metadata refresh of the same app and replica. Changing the app, endpoint or replica starts a new panel context: an old pending action cannot disable controls in the newly selected process, and its later reply cannot populate the new view. Local Inspect credential changes also reset that context. Already submitted server work is neither cancelled nor repeated.

The budgets panel validates limits and cost attribution before displaying a snapshot. Invalid or failed reads hide retained totals instead of presenting them as current values. Use Refresh budget snapshot to retry the read; the selected replica and tenant filter stay in place. This action reads the accountant and does not reset budgets or replay costs.

Opened AI-flow details in single-replica and all-replicas views retain their original replica and run ID if that process leaves. The departed observation is marked unavailable; its old content stays hidden and inert. Open the run explicitly from an available replica to inspect its current state, then close the departed observation. A user-initiated switch between individual process replicas resets local detail selection rather than reusing it against a different source.

Routes and data

Web routes form an expandable URL tree. Parent pages remain selectable alongside nested and dynamic routes. Select a page to see its file, render mode, hydration, cache settings and inherited boundaries. Expand or collapse the complete tree with the toolbar. The local app overview reuses the same RouteExplorer and adds its live route metrics to the selected page.

Data explorer remains visible for frontend apps. A frontend has no database of its own: select an API data source to open the existing table editor. The local dashboard marks API relationships declared by the frontend; Cloud offers the API apps in the current project and preserves the selected environment. The shared DataSourcePicker accepts host-provided links and never handles credentials.

The data editor has a table sidebar, filters, sorting, pagination and row actions. Click an editable scalar cell or focus it and press Enter to edit it; Enter saves, Escape cancels. Write access and table/column restrictions still apply. System tables are grouped separately and read only. On mobile, the table list scrolls inside a bounded area so the selected table stays reachable.

The table selector shows loading and read failures on desktop and mobile. A failed inventory read is not an empty database. Retry reloads the table list without reloading the dashboard; previously loaded table names remain available if a refresh fails.

Find an app capability

The navigation groups app configuration, data and storage, automation, product services, and health and activity. All groups are expanded in the sidebar. On a narrow screen, open Navigation to choose a task. API and web views follow the inspected app kind; Data explorer, environment variables, metrics and logs remain available for both kinds.

The plugin inventory marks which views have an installed provider. Views remain listed so the task catalog is discoverable. An unavailable inventory is not evidence that a plugin is absent.

Plugins

Literal GET routes in the plugin inventory link to the registered app address. Replica selection scopes Inspect reads; these public links use normal HTTP routing and carry no Inspect credentials. POST routes and parameterized route patterns remain non-clickable metadata.

The Plugins view lists configured instances, activation and install-hook status, canonical package identity and the actual inspect mount. Expand an instance to see its permissions, hooks, procedures, schema contributions, services, templates and declared dashboard extensions. It does not disclose configuration values. A declared extension is metadata; listing it does not execute its bundle.

Every plugin panel resolves its instance from this inventory. With several instances, choose one before any plugin read or write runs. The choice survives Cloud's Refresh action; changing instances clears old data and action state. Cloud verifies package identity, effective mount and declared endpoint method before forwarding. An absent plugin and an unavailable inventory are separate states.

Rate limits, under Health & activity, shows ordered rules, the RPC gate, the independent HTTP IP shield and actual process-local limiting decisions. Multiple limiter instances require an explicit selection. Store errors and unbound-store bypasses are separate from checked-and-allowed requests; unknown bucket counts are not shown as zero. See Rate limiting for scope and configuration details.

Standing observations

View What to inspect Read endpoint
Data expectations Holding, violated or unknown rules; measured value, threshold and last violation cause /_voltro/inspect/expectations
Compute budgets Per-tenant usage, warning/limit, observe/suspend behavior and cost attribution /_voltro/inspect/budgets
Experiments Per-variant exposure, metric, baseline, holdout and relative/absolute difference /_voltro/inspect/experiments
Invariant checks Pass, fail or unavailable, concrete findings and suggested next step /_voltro/inspect/checks
Agent tools Admitted tools, app-enforced approval and policy exclusions /_voltro/inspect/agent/tools

Development and production read the same standing registries. Their observations are process-scoped, including when the underlying data resides in a shared database. A capture time identifies the snapshot; it does not establish that every replica has observed the same writes.

Compute budgets measure framework cost units, not currency. Attribution is cumulative since boot or reset; a budget may have its own rolling window.

The suspend policy describes how a budget-aware workflow should react before further spending. The in-memory accountant records usage and emits budget signals; its counters alone do not pause arbitrary work. Workflow code must connect the pre-spend check to a durable hold. The dashboard reports the configured policy, not confirmation that all work is gated. Experiments count assigned rows, not unique people. Undefined lift is displayed as a dash. These results provide no significance test or confidence interval.

An unavailable check is not a pass. Source checks can be unavailable in a built production artifact; read the reason and run the check where its inputs exist. Agent tool inventory grants no execution permission. Calls require an app subject credential and follow the app's authorization and approval policy.

Metrics

Invocation snapshots and the metric registry are validated independently before rendering. An invalid or failed read hides that section's previous measurements; a healthy section remains available. Refresh metrics, when supported by the provider, retries the affected read without resetting filters or sorting. Missing initial data remains a loading state. JSON-safe special registry readings (+Inf, -Inf, NaN) remain valid and are shown as supplied.

API and web apps report a bounded invocation window (normally 60 seconds) with measured latency percentiles in milliseconds. Web development and production group page requests by route pattern, so different IDs share one row. HTTP responses with status 500 or higher count as errors. Inspect polling and the dashboard proxy do not count as page traffic. The page labels the time basis and lets you filter or sort by calls, errors and p95. Providers returning cumulative registry samples are also supported; their percentiles are estimates from histogram buckets, explicitly distinguished from measured window values.

Below the invocation table, All metric series reads the full registry. Invocation and histogram tables are keyboard-focusable; use the arrow keys to scroll wide tables on narrow screens. Errors use theme-specific contrast while their numeric counts remain explicit.

All metric series reads /_voltro/inspect/metrics/registry for both API and web apps. Search metric names, descriptions and labels, or filter by counter, gauge, histogram, summary or frequency. Expand a series to inspect its description, labels, values, cumulative buckets, quantiles or outcome counts. This includes recorded database, partial-prerendering, queue, AI and custom series; absence means the process has not registered that series, not that the feature has no activity elsewhere.

This is a process snapshot, not a historical chart or fleet sum. Counters reset with the process. Histogram boundaries use +Inf for all observations; -Inf and NaN readings remain explicit instead of becoming zero or null. Use metrics export for retained history and aggregation. Cloud project Metrics links to each connected app’s measurements.

The Cache view keeps its hit rate unmeasured until the first cache request. Zero hit/miss counters with “No cache requests yet” differ from a measured zero-percent hit rate after requests that all missed.

The app context uses a compact row: the return link, app name, address and status stay together above the inspector. Dashboard tabs sit directly below the masthead, keeping the working area close to the top of the viewport.

Working with records

When editing an existing record, validation applies to changed fields and outstanding input errors. Unchanged server values, such as dates serialized as timestamps, do not block an unrelated edit. Creating a record still validates all editable fields except omitted database defaults.

Filtering fields in the record editor preserves unfinished inputs, including invalid JSON and numeric text. A failed validation reveals the fields again and focuses the first invalid control. If a linked-row lookup fails, Retry linked rows repeats that read while keeping the record draft and returning focus to the reference search. Choices from the previous search are hidden while the new search is pending.

Dashboard checkboxes use the shared Checkbox from @voltro/ui-shadcn, including workflow run selection, filters, confirmations, access controls and Cloud settings. The shadcnWidgets.checkbox form renderer uses the same component, with consistent checked, mixed, disabled and keyboard-focus styling. Native input semantics and label interaction are preserved.

Updates are always automatic. Live · updates automatically is a connection status; Data source details only expands observation metadata. Changed cells briefly highlight in violet, rows newly entering the visible page in green, and CDC-confirmed deletions in red for 500 ms before disappearing. Page, filter, search and sort changes establish a fresh baseline without flashing. A row leaving a filtered or paginated result is not proof of deletion. After a stream gap or a resync without row identities, snapshots recover the current data without inventing red deletion signals. Interrupted connections reconnect automatically, with a visible reconnecting status and snapshot refreshes every 15 seconds during downtime. Reduced motion uses a static confirmation tint; active cell editors retain their draft and focus during updates. If the edited record leaves the result, editing ends with a notice and the controls unlock.

Drag the divider beside the table list to resize it independently. Hover a table name briefly to see its full name, or focus it with the keyboard. Column boundaries have visible resize handles; drag them or use the arrow keys. Double-click a handle to restore its default width.

The shared Data explorer in local Devtools and Cloud uses compact rows, a sticky column header and row actions on the left. Resize a column by dragging its edge or focusing the separator and pressing the arrow keys. Use Columns to find and hide fields; the final visible column cannot be hidden. On narrow screens, choose a table from the selector and scroll the grid horizontally.

Row search waits briefly while you type. Filter edits a local draft: complete the conditions, then choose Apply filters. Resetting filters restores the unfiltered result. Clicking a scalar cell opens an inline editor; Enter or the save control commits, Escape cancels. Finish that edit before changing the view. Empty text and explicit null are different values.

The row action opens a searchable editor with complete values and typed fields. On creation, Use database default leaves that column out of the request so the database assigns it. Required fields and malformed JSON prevent submission. Reference fields can search and select a record from the referenced table; the grid's reference link opens that table filtered to its primary key. Save errors retain the draft. Closing with changes asks whether to discard them, and deleting one or selected rows requires confirmation. Read-only capabilities continue to hide writes, and the server remains the authority for access.

Refresh requests a new snapshot through the host. Hosts may expose an optional DataSource.refresh callback; successful edits also request it. Source and capture details are available below the toolbar; incomplete observations remain visible without opening the details.

Last recorded row change

Open a row in Data explorer to inspect its last recorded change. The panel shows the audit actor and timestamp, plus a trace identifier when available. Missing audit fields, an unknown actor and a row that no longer exists have separate states. It reads /_voltro/inspect/provenance with the same field mask as the row explorer. Cloud requires an owner or admin for row and provenance reads; resolving a cached row still checks app ownership and current membership.

This is evidence from the row's latest audit fields, not a complete history or an attribution for each individual field. The Time travel view remains the place to inspect retained row-history snapshots when that plugin is installed.

Failed reads and custom hosts

A failed read must remain an error, distinct from a successful empty snapshot. Custom @voltro/devtools-ui hosts supply DataSource<T> hooks and enforce authorization in their transport. The shared CDC, flags and governance pages require the dead-letter, audit and subject-graph hooks respectively. Preserve all response fields rather than reducing them to the original summary rows.

For Mail, preserve process/declaration observation metadata and provide Capabilities.canPreviewMail only when the operator may render a template with the app's inspect write credential. A stored message is not evidence of a live connection, and a pending or failed read must not be rendered as an empty outbox.

Inspect access and refresh

Once the local dashboard has learned recent, authorized fleet addresses, both read requests and live-stream reconnections can use another entry point when the original becomes unreachable. Stream requests retain their explicit replica ID: an unavailable selected process is still reported as unavailable. Authentication and application errors do not trigger fallback, and failed writes are never replayed.

An inline cell draft survives temporary row or table-metadata read failures while the current data view stays open. This includes unfinished decimal text. Recovery restores the draft without submitting it or replacing it with a refreshed value. Saving still compares against the value captured when editing began; an external change cannot silently become the new write expectation.

The local data page also keeps its mounted editor when app-metadata reads fail, including when all API replicas are temporarily unavailable. The failure remains visible, and fresh reads resume automatically. Changing the app, endpoint or Inspect credentials resets the editor context; a successful app-kind change switches to the appropriate view. Initial metadata failure does not assume an API or grant write access.

An inline save remains locked until its response arrives, even if a temporary row or table-schema read failure removes and restores the grid. The returning editor cannot submit a second write or cancel the pending one. If the write fails while the grid is unavailable, its error and raw draft reappear together when reads recover. This does not automatically replay a failed write or establish whether a missing response committed.

If an inline write rejects, the editor reports Save not confirmed rather than claiming that nothing was stored. It requests a fresh row snapshot when the host supports refresh and shows the Last observed value beside the retained draft. That read is an observation, not a receipt for the failed request. Error details remain expandable. An explicit retry keeps the original compare-and-set expectation; it does not silently adopt the newly observed value. Cancel only closes the draft and cannot undo an already stored change. Narrow columns wrap editor actions so the recovery explanation and controls remain reachable without overflowing the cell.

The local data explorer combines the selected app's replica change feeds on one browser connection. It reports a complete live connection only when fleet discovery is complete and every member's feed is connected. An unavailable inventory retains known feeds and marks the connection as reconnecting; it does not imply an empty fleet. Changing tables, filters or pages cancels obsolete row requests without reconnecting the stream or resetting the scroll position. Stream reconnects reconcile the current table; failed handshakes do not trigger extra reads. During an interruption, snapshots continue every 15 seconds. For loopback targets, both snapshot and stream proxies resolve the selected app's read token from the runtime registry; an explicitly supplied read token takes precedence.

The Inspect access view stores the inspected app's read token and a separate write token. They must match VOLTRO_INSPECT_TOKEN and VOLTRO_INSPECT_WRITE_TOKEN in that app. GET requests send only the read credential; actions also send x-voltro-inspect-write. A valid read token without the write token remains a read-only connection.

In Cloud, only an organization owner can change these credentials. The browser receives configuration status, never saved token values. Members cannot perform inspect actions; admins can operate services, while schema, row-deletion and bulk-run actions require an owner. The server enforces these checks. Leaving a field empty keeps its saved value; removing it requires the explicit checkbox. Removing the saved copy does not revoke the credential in the inspected app.

The local Inspect access page distinguishes editable browser credentials from credentials held by the dashboard server. A browser override takes precedence; removing it restores the server credential when one exists, rather than revoking access. Server-held credentials have no removal checkbox. Saving for an automatically discovered app creates its browser registration under the existing app identity; replica selection is not stored in the app URL. Shared hosts can expose server fallback availability through InspectAccessData.readOnServer and writeOnServer; readConfigured and writeConfigured continue to describe the credentials editable through the form.

Saved registrations continue to follow current server-credential availability from discovery when app identity and address match. Browser credentials are retained; a different target with the same ID cannot contribute access flags. Changes to the browser registry in another tab update open dashboard views without reload, including credential removal. Unfinished credential fields remain untouched. Malformed stored registrations are ignored instead of replacing the current valid registry.

An explicit browser read token does not inherit the dashboard server’s write credential. Without an explicit browser write token, the local dashboard hides mutation controls and the access form explains how to configure the matching pair or return to server credentials. The inspected server remains responsible for authorizing every request.

The local dashboard stores credentials in this browser's app registry. A deployed dashboard holds both token and writeToken for its targets in VOLTRO_DASHBOARD_APPS and attaches them itself; the browser learns only that the pod holds them, behind the dashboard's own lock (VOLTRO_DASHBOARD_TOKEN, the login page). Its proxy forwards the separate write factor and never adds local write authority to an explicitly supplied read credential.

Every token the dashboard server attaches itself — a configured target's, or a local app's from the runtime registry — is lent only to a requester it trusts: a session signed in under VOLTRO_DASHBOARD_TOKEN; a client in a network listed in VOLTRO_INSPECT_TRUSTED_CLIENTS (read through the proxies in VOLTRO_TRUSTED_PROXIES, locked or not); or, on an unlocked dashboard, its own machine over a direct loopback connection addressed as localhost. A request from another address, relayed by a reverse proxy on the same host (it carries X-Forwarded-For or a similar header), or forwarded by one that adds no header (its Host is not a loopback name), gets 401 inspect proxy refused with the reason and the fix. Reaching a local dashboard through a tunnel or a dev gateway therefore needs the lock: set VOLTRO_DASHBOARD_TOKEN and sign in.

Cloud's external inspect queries are snapshots. Use Refresh to fetch current values. A subscription to the Cloud app row does not subscribe to the external app's in-memory counters. Workflow and schedule records with a dedicated change-feed bridge update through that bridge.

Expand Snapshot · Read only beside Refresh for the access explanation and the Inspect access entry. The local dashboard uses the same Read only disclosure when credentials are missing. The current process and capture time remain visible with each observation.

The RPC view includes queries, mutations, actions and streams, including their JSON schemas and declared scope, resource-policy or open-access decisions. Stream schemas describe each element; consume them with useAgentStream in the app. Inspect credentials do not grant an application subject.

Local inspectors derive action availability from the registered app's read and write credentials. A read-only connection keeps inspection available but hides write actions. For deployed dashboards, runtime configuration reports each server-held factor separately; secrets remain on the server. Credential availability does not replace validation by the inspected app.

For manual schedule starts and backfill admission in the local dashboard, choose a single replica first. The page shows the selected target; combined views show selection guidance and keep run history readable without exposing write controls. The selected replica receives the action; combined and all-replica selections are rejected before sending it. This selects the admission endpoint, not a guarantee about which worker will later execute a durable backfill.

RPC inspection

A temporary failure to read RPC definitions preserves an already open execution form in the same inspection context. The stale catalog and editor are hidden and unavailable until a successful read restores them. Unsaved input and an in-flight result survive this interruption; recovery never resends an invocation. Changing the app, endpoint, replica or credential context still discards the previous form.

Invalid JSON is rejected in the form before a request is sent. Inspect validates the input against the procedure schema and applies its transformations before invoking the handler. A schema error shows the failing field and does not execute the procedure.

Inspect execution is available in both voltro dev and voltro serve. Both use the normal guarded mutation/action runners, including plugin interception and write attribution. Internal procedures are excluded; an inspect read token alone cannot execute writes.

The RPC inspector searches procedure names and source files within the selected kind. Procedures are grouped by namespace and can be opened with the keyboard. Select a procedure to inspect its input, output and error JSON schemas and access rules. Missing schemas are identified explicitly rather than shown as empty objects. Cloud and local inspectors use the same explorer.

Procedure details also show reported source tables, write targets, public-API annotations and agent-tool annotations. These declarations do not establish caller authorization or deployment exposure. Explicitly internal procedures remain inspectable but never show an execution form. An absent internal marker does not prove public reachability.

Workflow entries in the RPC catalog expand to show the complete source path, payload schema, triggers, flow control, messages, version compatibility, patch markers and access declaration reported by the app. Missing metadata is explicitly unavailable rather than an inferred empty configuration. The catalog is read-only; workflow execution remains in the workflow tools.

Changing a saved browser read or write token resets an open local RPC execution form, including its payload, tenant choice and confirmation. Unchanged observations retain the draft. Hosts must change RpcPage.invocationScope when their execution context changes, including credential changes, and use an opaque key rather than credential values. This resets presentation state only; requests already sent are not replayed, cancelled or undone.

Before the first RPC snapshot arrives, the inspector shows loading without empty counts or file-creation guidance. A successful empty catalog remains distinct from a search with no matches, including workflow searches. Change or clear the search to restore filtered entries.

Workflow detail, trace and back links within the dashboard retain the active replica selection. External trace-provider links remain unchanged.

Process-specific replica comparisons initially open two observations. Open additional replicas as needed; closing an observation unmounts its data providers. Shared data editors and combined logs/metrics retain their existing selection semantics.

For mutations and actions, the RPC inspector offers execution when the viewer has inspect write access. Enter JSON, choose a tenant or explicitly omit the tenant header, then confirm the operation. With one replica selected, execution targets that replica. Combined and all-replica execution are rejected; an unavailable target never falls back to the entry replica. Without a replica selection, execution uses the connected app endpoint. Application guards still apply. Results and errors are displayed separately.

Workflow recovery uses the connected Retry, Resume and bulk recovery actions. Integrations supply useRetryRun, useResumeRun and useBulkRuns for these operator workflows.

Bulk replay returns per-run durable observations: same-execution redrive reports restart entry, while fresh retry reports admission and eventual acceptance of a separate execution. A queued or unconfirmed request is not a completed action, and engine acceptance does not mean the workflow completed successfully.

Both bulk action surfaces distinguish accepted recovery actions from completed workflow executions. Per-run failures retain their full identity and reason, wrap long text, and remain accessible in pages of 20; the report does not discard errors after the first five.

Retry captures a deliberate fresh execution intent with a persisted request ID and the original (or edited) complete payload. Reusing the same ID observes the same intent; it does not start another execution. Redrive resumes the original execution from its journal. Bulk retry excludes successful original runs. If a previewed run becomes ineligible before Apply, its never-reserved request is durably closed without starting; an existing queued or accepted intent remains unchanged. The result can be recovered after reload, and a delayed submission of the closed ID cannot revive it.

Bulk workflow actions apply only to the run IDs returned as eligible by the preview; newly matching runs are not included. Eligibility is checked again when applying, so runs that have since completed can be skipped. While a preview or action is pending, its filters and operation are locked and duplicate submissions are prevented. Changing any field discards the preview. After a failed request, review a fresh preview before applying again; the entered filters and reason remain available.

The same confirmation rules apply to checked workflow rows. Changing the selected run IDs resets their confirmation; a delayed response for an earlier selection cannot authorize the new one. Reordering the same IDs preserves the preview. Changing the reason invalidates it, and an empty eligible set cannot be applied.

Bulk cancellation returns targets (the eligible run/workflow/execution identities) and controls (structured control receipts). The dashboard saves per-run request identities before dispatch, forwards them as request controls, and restores their observation after reload or a lost response. An accepted cancellation is neither a confirmed success nor a failure; its receipt is tracked in the workflow control section. Only confirmed cancellation contributes to succeeded. A changed execution identity is refused before dispatch. Custom useBulkRuns providers must preserve both fields and the supplied request identities. Standalone BulkRunActionsPanel and SelectionBar integrations provide prepareControls and observeControl; WorkflowsPage connects its existing journal automatically. The journal retains at most 128 references; a batch exceeding available capacity is refused before any write is sent. Review completed receipts or choose fewer runs. A storage failure prevents dispatch and removes the newly written references from that preparation attempt.

If a previewed cancellation target finishes before Apply, the server records its existing outcome as already terminal. This is not a successful cancellation: the request did not cause the run to finish. The durable receipt survives a lost response and reload, preserves the operator reason, and prevents the same identity from cancelling a later generation. Existing accepted requests remain unchanged. Missing or active targets are not given fabricated terminal receipts.

If a previewed redrive target becomes ineligible before Apply, its unreserved restart request is permanently withdrawn under the resident reservation lock. The withdrawal remains readable after reload or a lost response and prevents a later submission of the same request from restarting the run. Existing pending or entered restarts are returned unchanged; their capacity and engine work are not cancelled. The server validates the previewed workflow/execution before creating a withdrawal.

Restart status reads locate the durable request or withdrawal independently of its original run row. A retained receipt therefore remains observable after the run is deleted, including in registered physical namespaces. Ambiguous identities, contradictory reservation/withdrawal records or incomplete physical discovery fail explicitly; they do not fall back to another store. This read-only recovery does not bypass live-run validation for new restart mutations.

Fresh-retry status reads likewise locate the retained retry receipt by its original run ID and request ID, without requiring the original run row. Accepted and non-started outcomes remain readable after run deletion and a dashboard reload. Discovery covers registered physical stores and namespaces; ambiguous or incomplete discovery fails explicitly. This read-only recovery does not relax validation for new retry submissions.

Every run has its own page (…/workflows/runs/<runId>; the run rows link there): a header with status, source, version, parent, trace, absolute start and live duration; only the actions that apply to the run's state — Cancel and Signal / Update for a running run, Resume for a suspended one, Retry, Retry with… and step recovery for a terminal one; and a timeline in body order on a time axis — steps with their attempts stacked, durable sleeps, signal waits and child runs — each selectable (mouse, ↑/↓, j/k) into a side panel with input, output, error, stack trace and retry policy. The run's payload, output and lifecycle events sit below. There is no Suspend button: an api refuses every external suspend, so the only honest suspension is the workflow's own awaitSignal / sleep.

The run timeline covers the latest observed child completion, even when the parent has already finished. An open child keeps the timeline clock moving; the parent header retains the parent’s own duration. Terminal parent recordings without completion evidence remain unconfirmed rather than appearing active.

Workflow timeline tick labels adapt to the actual plot width. Offsets start at +0ms; narrow panels show fewer labels while preserving bar positions and the full time range.

Run headers, run rows and child rows show elapsed time from their recorded start and completion timestamps, including suspension. Open runs use the current observation time. Missing or contradictory timestamps show an unknown duration. This differs from the recorder’s durationMs, which measures the last body attempt and may be zero when a suspended run is cancelled without entering its body again; recorded execution statistics retain that metric.

The definitions tab starts a workflow with a JSON payload ("Start run…", also offered when a workflow has no runs yet), through the same inspect start endpoint voltro workflows start uses; the start runs under the operator identity and through the workflow's own guards. Cancel, Resume and Retry show action errors on the affected run. While a request is pending, competing actions are disabled. A completed request is reported separately from the live workflow status; failures can be retried.

The definitions tab is a table: per workflow its declaration as chips — event triggers (*.trigger.tsx), schedules, flow control (concurrency 4 / key, debounce 5.00s, throttle, rateLimit, singleton, batch, timeouts), version with patch count, and access (the scopes a caller must hold, internal, or open with its reason) — beside a 24-hour sparkline of its runs (an hour turns red when one failed), the window's started and failed counts, and the runs in flight. Everything on that row is read off the definition the api registered, so the page cannot describe a workflow the api does not run; an older api that reports no declaration shows name and file only.

A workflow's own page adds a Declaration card — the payload fields with their types and optionality, the triggers with their cron, flow control, the signals and updates it accepts, version, compatibility and patches, access — and a Steps over the window table from the same stats endpoint: per step the runs it appeared in, retries, failures, p50 and p95, with a bar relative to the slowest step. The stat tiles show the window's p50, p95 and maximum duration from the server (latency on /_voltro/inspect/workflows/stats) rather than from the loaded page. "Start run…" opens on a payload built from the declared schema — required fields first, default and example honoured, placeholders by type — with the schema's one-line summary beneath the editor.

The runs tab opens with a Needs attention block: failed, stuck (running longer than three times the window's p95, never under five minutes), waiting (suspended or paused) and running, each a tile that applies the matching status filter. The filter bar has time presets (15 min, 1 h, 24 h, 7 d) beside the custom range, and every active filter is a chip with its own × under the bar.

In the local dashboard the run list, the stats, the run page's steps and events refetch when the api's inspect stream reports a change on workflowRuns / workflowSteps / workflowEvents (one refetch per burst); the four-second poll remains as the fallback for an api without the stream. The change stream follows the shared store rather than the selected process set, so selecting several replicas does not disable notifications. Every successful stream handshake, including reconnection, triggers a coalesced refresh to recover changes missed during the interruption.

The sparkline is drawn from the server's per-workflow bucket series at the time preset's resolution — five-second buckets over the last fifteen minutes, twenty seconds over an hour, five minutes over a day, an hour over a week — as an area line with a red marker per bucket that had a failure and a per-bucket tooltip (time to the second and counts) on hover. The throughput chart uses the same window and buckets.

The in-page console's Workflows scope is live the same way: it opens the api's inspect stream through the dev proxy (workflowRuns, workflowSteps, workflowEvents) and re-reads the moment a row changes; its poll is a ten-second fallback. The cloud dashboard mirrors runs, steps and events into its own tables from each app's stream (server-side), so those views are push-updated there too, and its stats and flow-control reads refresh when the mirrored runs change.

A workflow's page carries its admission at the top: admitting or paused, how many starts are waiting, holding a slot or dead-lettered, the controls it declares, the queued intents with their "19 starts folded into this one" — and Pause (with a reason) / Resume right there, the paused state visible. A Versions over the window table follows when the api answers byVersion: runs, success rate, failures, p50 and p95 per recorded workflow version, newest first — the after-deploy comparison. The Needs attention block gains a Dead-letter tile from the admission read; it opens the Flow tab. The placement input on the Flow tab sits behind an "Operator" toggle.

The events tab has Send event… and every logged event a Replay (the same modal, prefilled with that event's name and payload): the name is limited to what the api knows — declared triggers and logged names — and the receipt lists every workflow the event started. A delivery whose run is loaded links to the run's page. Ticking run rows shows a selection bar: Cancel (with a reason) or Replay over exactly those rows, previewed as a dry run first (eligible vs. skipped, with the reason), then committed by run id. "Start run…" takes an optional tenant; the run then executes as a service account in that tenant with operator authority. Saved views are chips in the filter bar.

Sending and replaying workflow events is also available through an inspect-enabled compiled production host. Replay emits a new event with the same name and payload; trigger idempotency can prevent another start. Replica selection is preserved when loading an event’s delivery list. Each filtered or duplicate delivery remains visible for that event as skipped, with its reason, even after reloading. Repeated filtering does not become a delivery failure. Skipped deliveries are displayed neutrally; failed delivery messages remain readable in full on narrow screens. Replay is a separate keyboard-accessible button. A started delivery confirms workflow submission, not successful completion; inspect the linked run for its eventual outcome.

The Flow tab also shows the offloaded inference queue. Loading, a missing snapshot, an app without registered workflows, and an active but empty queue are distinct states. If no dispatcher has reported, the panel says so instead of disappearing. A failed read hides retained queue health and shows the read error; an empty list is not evidence that a dispatcher is healthy.

The run page shows the run's admission row when the ledger has one ("19 starts collapsed into this run (debounce) · waited 4.2s"), a nondeterminism warning when the recorder flagged a replay that reached a step other than the recorded one (the step name selects the timeline entry), and for a retried step an attempt diff in the side panel — input and output of this attempt against the previous one, line by line. Operator actions keep their receipts under the header (request id, time, result), filtered to this execution.

The admission overview’s Starts collapsed counter counts additional starts merged into a shared execution: independent starts contribute zero; twenty starts folded into one execution contribute nineteen. It covers queued groups and admitted ledger entries. Individual group/run details retain the total number of starts represented by that group, including its original start.

“Retry with…” creates a separate execution and keeps the original run unchanged. The payload dialog retains its draft and explains conflicts or an unconfirmed response without an unhandled browser error. Use Review saved request to inspect the existing request; dismiss a confirmed observation before choosing a different payload for another retry. A missing response alone is not permission to submit a new identity.

Cloud account settings show your sign-in email and let you edit or clear your display name (up to 120 characters). Saving updates only the signed-in user; it does not change the email or login method. Failed saves retain your input for retry. Organization membership, API keys and billing are linked from the corresponding organization.

Procedure details follow the visible tab and search results. Switching away closes the execution form. A catalog read failure hides prior procedures and their actions. Query/stream details explain that these run as application-client subscriptions; missing write access or an unwired execution connection is stated explicitly.

Cloud profile saving treats the server-confirmed name as saved immediately, even before the profile subscription catches up. Whitespace-only differences do not enable another identical save.

When Cloud paid billing is not enabled, the organization billing page displays its launch status without mounting invoice, subscription, portal or seat-purchase providers. Organization member management remains available separately.

The table catalogue accepts every declared database column type, including real, decimal, bigint and arrays. Real and decimal fields use numeric editors and numeric range filters; arrays use JSON values. Binary, raw and bigint values are currently read-only in the grid until their lossless editing codecs are available.

When a selected replica has no reachable address, the inspector names that replica in the failure message. Cloud preserves the structured upstream diagnosis; an explicit single-replica read does not fall back to a different process.

Cloud environment selection reads the URL query independently of the pathname. Project and app navigation retain the selected environment. Removing variables, members, invitations or API tokens requires an in-app confirmation; failed actions remain open for retry. Local registry clearing uses the same confirmation component.

Cloud environment secrets are written server-side to the existing Secret Manager provider. The control-plane database stores only a server-only secretRef; list and mutation responses contain neither secret values nor vault references. Configure SCW_SECRET_KEY and SCW_PROJECT_ID on the API and worker. Both use SCW_SECRET_REGION (default fr-par) independently of the workload region. Missing configuration or provider failure rejects the write and keeps the form value for retry. Each write creates a separate vault reference: the database update activates the new value, so a failed database write cannot rotate the previously stored secret. References retained by existing deployments must not be deleted during rotation.

Container deployment resolves variables in this order: app/current environment, app/default environment, project/current environment, project/default environment. An unset project default means production. Plain values enter ServiceSpec.env; secrets enter secretEnvRefs and the RuntimeProvider resolves them. Ownership is checked and platform-managed keys cannot be overridden. A secret without a vault reference fails deployment explicitly.

Resending an organization invitation disables concurrent invitation actions until the request completes. Success and failure feedback identifies the recipient; a failed request can be retried.

When billing is enabled, changing the purchased seat count first requires a successful provider price preview. Review the quoted quantity and proration in the inline confirmation before applying the change. The quantity is locked during review; cancel to edit it. A failed preview never implies zero additional cost and does not change the subscription. An unavailable seat summary displays an unknown count rather than unlimited seats.

The data explorer preserves decimal values as strings when editing and filtering, including trailing decimal places. Decimal filter operands must be exact strings rather than JavaScript numbers. Memory-store queries, ordering and filtered updates/deletes compare declared decimal columns exactly, including equal values with different scales. Text columns retain text comparison. Reactive matchers use the same typed comparison for old and new rows, including values entering or leaving a decimal filter. Decimal conditions are evaluated exactly after candidate routing on other eligible constraints.

Integer edits require whole decimal digits within JavaScript’s safe integer range; fractional or rounded drafts are rejected. Vector edits require a JSON array of finite numbers. Invalid drafts show a field error before a write is attempted.

The inspect catalogue includes vectorDim for declared vector columns. Both dashboards validate this length in cell and record editors and show the required number of elements.

Invalid decimal drafts stay in the editor for correction without changing the record value. While an inline save is pending, Escape does not dismiss the editor.

Record submission revalidates field values using the same parser as cell editing. Values produced by controls such as the NULL toggle must also satisfy the declared type and vector length.

Graceful shutdown in development and production stops replica observation publishing, waits for an in-flight publication and removes that process’s observation records. Crashed processes still require membership/freshness diagnostics; a missing membership source cannot prove that a silent process has departed.

The storage plugin exposes POST /_voltro/inspect/plugins/storage/delete with { "refId": "…" } for inspect operators with write access. It delegates to the storage service, removing the reference and its grants and releasing bytes when no other reference uses them. Local and Cloud dashboards offer deletion after selecting a file, with an explicit confirmation naming the target. The dedicated canDeleteStorage capability controls availability; server write authorization still applies. Failed deletion stays open for retry and successful deletion refreshes supported data sources. Upload is not yet available in this interface.

Storage statistics aggregate the entire reference index by tenant and visibility, including inventories beyond 10,000 objects. DataStore-backed statistics use a grouped aggregate query rather than loading every object. Counts describe references, not unique deduplicated provider blobs.

Plugin inspect endpoints can return kind: "bytes" with contentType and byteStream, using the same lazy Web ReadableStream contract as plugin HTTP routes. Inspect authentication runs before the handler. Binary responses are not wrapped in JSON observation envelopes, even for JSON-file downloads. The API transport opens lazy sources only for the body, propagates download metadata and cancels the stream on disconnect. This transport capability does not by itself add a Storage download button or a Cloud binary proxy.

Storage exposes GET /_voltro/inspect/plugins/storage/download?refId=… to authorized inspect readers. It streams the referenced file as an attachment with a UTF-8 filename and no-store caching; it does not mint a public URL. Trusted server code can use StorageService.getStream(id, { tenantId }), which checks tenant scope like get and opens the provider lazily when consumed. Private end-user access still requires authorization before calling this method. Native provider streams are preserved by both inspect downloads and the ordinary serve route. Providers without getStream use a buffered fallback.

The local dashboard HTTP proxy streams inspect responses in both development and production start. Download metadata is preserved and disconnecting the client cancels the upstream request. When fetch decodes a compressed response, the proxy omits its compressed Content-Length. Target restrictions and per-app credentials are applied before forwarding; upstream cookies are not forwarded.

The Cloud API provides a binary storage-download REST handler at /apps/:appId/storage/:inspectSlug/files/:refId/download. It requires authentication and cloud:console scope, reuses app tenant/membership/role checks, and verifies the storage mount against the app manifest. File streams and attachment metadata are forwarded without exposing inspect credentials or upstream cookies.

The Cloud download route is explicitly registered in the API configuration. Missing apps or storage mounts return HTTP 404; denied tenant or membership access returns 403. Requests without authentication are rejected with 401.

Local browser download handoff

The dashboard exposes POST /api/dashboard/proxy/download with JSON { "target": "<storage inspect download URL>" }. The caller may supply its inspect bearer in the Authorization header; otherwise the existing server-held per-app credential rules apply. The response contains a same-origin URL valid for 30 seconds and one GET, bound to the current dashboard cookie. No inspect credentials appear in that URL, and no write factor is forwarded. Only allowed storage-download targets are accepted, with the target checked again on consumption. The dashboard session gate applies to both requests in dev and start. Pending handoffs are bounded; cross-origin browser issuance is refused.

Select a file and choose Download file in either dashboard. Preparation errors remain visible for retry, and competing actions are disabled during preparation. The status confirms browser handoff, not completed file transfer. Local preparation probes access before issuing the one-use URL; Cloud performs a HEAD check through its same-origin /storage-files proxy. The Cloud proxy targets VOLTRO_PUBLIC_CLOUD_API_ORIGIN, the configured external API WebSocket origin converted to HTTP, or the default local API at port 4100. Set the API origin when using another local API port. The browser streams the attachment without first buffering the entire file in JavaScript.

Storage inspect upload tickets

POST /_voltro/inspect/plugins/storage/upload-ticket requires inspect write access. Provide tenantId and ownerId explicitly (each a non-empty string or null for intentional unattributed scope), a key, contentType, positive integer size, and optional visibility (private by default). The response contains uploadPath, expiresInSec (300) and maxBytes. POST raw file bytes to that signed path on the same inspected app. The ticket cannot accept more bytes than declared; configured upload size limits are checked before minting. The ordinary storage upload route still enforces scanning, quota and normalization through StorageService.put. Tickets are temporary bearer capabilities and must not be logged or shared. This endpoint is an operator capability, not an anonymous ticket-minting route. The dashboard upload form and its host transports are not yet connected.

The Cloud API exposes apps.inspectStorageUploadTicket with the same file metadata plus appId and inspectSlug. It verifies app membership, write role and the selected storage mount before forwarding the request with the app’s inspect credentials. The resulting ticket alone does not provide a Cloud binary-upload transport.

Upload, finalize, resumable and multipart tickets bind the exact storage plugin instance. Handlers reject tickets issued by another instance before accessing its provider. Code that uses the signing helpers must supply instance, the value produced by pluginInstanceName for that storage configuration; missing-instance tickets are rejected. This binding does not itself disambiguate multiple instances’ HTTP route mounts.

Named or aliased storage instances use a distinct /_voltro/storage/i/<hex-instance-name> HTTP mount for serving, uploads and resumable uploads. Always consume returned URLs rather than constructing them. The unconfigured default instance uses /_voltro/storage. The plugin supplies its mount through StorageServiceOptions.httpPath so returned file URLs target the same instance.

Local dashboard write actions display the inspect endpoint’s reason and suggested fix when access is denied. If the dashboard session itself has expired, they return to the dashboard login gate.

Date fields accept valid calendar dates in YYYY-MM-DD form; impossible dates are rejected rather than rolled into another month. Timestamp editors preserve milliseconds and display local time while storing an ISO timestamp. Saving an unchanged inline draft performs no write, including during a repeated daylight-saving hour.

An open record editor keeps the snapshot from when it was opened. Live changes do not mark untouched fields as edits or send them back as stale patches. A row leaving the current page does not discard the open draft. Updates include the opening values of exactly the edited columns as expected. The Inspect endpoint compares these values and writes inside one transaction; a changed or deleted row returns HTTP 409 and the editor retains the draft. Close and reopen the record to review the current values before retrying. Single and bulk deletion use one POST /_voltro/inspect/data/rows/delete request with table and rows: [{ id, expected }]. Each expected contains the full row snapshot captured when selecting the row or opening its editor. The whole selection (at most 500 distinct rows) is checked and deleted in one transaction. A changed or missing row refuses the entire operation; no partial deletion is committed. The selection/dialog remains available after an error. Clear and reselect after reviewing current values to make a new deletion attempt. Conditional edits and deletions use the store’s transaction-scoped row-lock query, so a namespace-bound store locks and changes the same physical table.

Environment inspection read states

The environment panel distinguishes loading, failed reads, and a successfully loaded empty declaration. If a read fails, previous variable states and summary counts are hidden until a successful response arrives. It does not present stale configuration as current.

Read failures retain the provider's diagnostic text, including errors returned as plain strings. In a replica comparison, a failed read hides only that replica's previous state; other replicas remain visible and the failed panel recovers when reads succeed again.

The environment inspect response includes declaration metadata and boolean states only. Declared defaults and examples are omitted, including for public variables; default satisfaction is still reflected in the status. The separate .env.example generator retains its existing declaration projection.

On narrow screens, environment names and descriptions wrap, with status badges on a separate line. Required, missing and default-satisfied states remain readable in both light and dark themes.

Shared inspection sections treat every error value other than undefined as a failed read, including null, false, 0, and an empty string. They hide section content during the failure and restore it after a successful read; these error values must not expose stale plugin details as current.

Plugin inventory reports whether activation completed during process startup. “Activated at startup” is not a health check and does not promise that external services remain available. Shutdown hooks do not reset this historical activation flag.

The plugin inventory count is shown only when a successful snapshot is available. Initial loading and failed reads omit the count; a successfully loaded empty inventory explicitly shows zero.

The plugin hook inventory includes change-event handlers, observability contributions, and REST/procedure discovery callbacks alongside interceptors and lifecycle hooks. Listing a hook never invokes it.

The agent tool view removes the previous capture time and source notice while loading or after a failed read, together with the tool details. Successful reads restore the snapshot metadata.

When external agent access is disabled, the tool panel shows the reason instead of an unusable search field or empty admitted/excluded lists. Once a new snapshot reports the surface enabled, the inventory returns.

Agent-tool search matches tool names, descriptions, procedure types and exclusion reasons.

Checks and the related inspection pages hide previous snapshot timestamps and provenance while loading or when reads fail. Source metadata returns only with an available successful snapshot.

Schema convergence is unavailable when the migration snapshot has no SQL inspection connection and therefore no live schema fingerprint. An empty placeholder snapshot does not count as a successfully compared database.

Migration inspection and schema-convergence checks use the active database dialect in both development and serve mode. Storage-equivalent representations, such as SQLite TEXT for timestamp and JSON fields, do not produce pending type changes solely because their physical SQL type differs from the declaration.

The migration view compares boot baselines using the same table ownership rules as the boot planner. Undeclared framework runtime tables can appear after migration without producing false drift. Explicitly declared framework tables and unexpected application tables remain part of the comparison. An unchanged full-catalog baseline from an explicit apply is also accepted.

The dashboard and voltro db drift share the same baseline comparison. When declared tables can be loaded, the CLI recognizes an unchanged boot-scoped baseline even if unrelated runtime tables have appeared. Genuine application schema drift still returns exit code 4; the read-only comparison does not accept or rewrite the baseline.

Migration history inspection uses database-specific pagination, including SQL Server OFFSET/FETCH. A successful history read allows the migrations panel and schema-convergence check to report the actual schema state instead of an unavailable result caused by incompatible SQL syntax.

Data expectations display null rates and their thresholds as percentages, preserving small nonzero rates. Freshness measurements and thresholds both include milliseconds. Unknown measurements remain a dash rather than a zero.

Expectation observations include the complete rule used by the evaluator. The dashboard shows both row-count bounds, identifies the inspected column, and separates a value-bounds rule’s allowed field range from its tolerated violation count or percentage. The scalar threshold still describes the reported metric; rule carries the complete condition.

When a store change does not provide the previous or new row needed to update an expectation, the evaluator reads the current matching rows again. This keeps row counts, scoped rules and value-bound violations correct for SQL changes with incomplete row images; the triggering write remains attached to a violation. Changes with complete row images continue to update the measurement incrementally.

Compute-budget usage, limits, warning thresholds and attributed amounts retain small nonzero values instead of rounding them to zero. Number formatting follows the dashboard language; the configured cost unit is preserved rather than assumed to be a currency.

Experiment conversion rates are displayed as percentages. Their absolute difference from the baseline uses percentage points (pp), while relative lift remains a percentage. Count, sum and average measurements retain their numeric scale. Small nonzero measurements and negative differences are preserved; an unavailable comparison remains a dash.

Running experiments reread their current population when a store change lacks a required row image. SQL updates and variant changes therefore replace the old contribution instead of counting both versions. Complete row images continue to update the experiment incrementally.

For an explicitly selected replica, a temporary metadata read failure does not remount the local inspector or reset its active filter. Failed observation reads still hide stale results; the selected view resumes automatically when access is restored.

In the all-replicas view, an unavailable fleet inventory keeps the last known replica panels mounted so filters and open-panel state survive. A notice distinguishes retained membership from fresh discovery; each panel still reports its own current read or error. A successful inventory refresh replaces the membership, including an empty list. Switching apps clears the retained membership.

Invocation metrics display — for latency percentiles when the cumulative registry has no usable duration observations (a missing or empty histogram, or no finite bucket boundary). Request counts remain visible. Sorting by p95 places measured latencies before unknown values; unknown latency is not a measured zero.

The cumulative invocation overview also includes plugin hooks. Each recorded hook duration contributes one invocation; the dedicated hook-error counter supplies failures. Duration histograms with the same hook label are combined before estimating percentiles, matching the RPC, HTTP and subscription presentation.

The route inventory distinguishes loading, failed reads and a confirmed empty result. During a pending or failed read, a retained route snapshot is not shown as current. The hierarchy returns when the read succeeds.

Route details show inherited layout, error, loading and not-found boundaries from the root directory down to the selected page. Filesystem route groups remain in this chain even when they do not contribute a URL segment; unrelated sibling directories are excluded.

The local app inspector requests plugin inventory only after the inspected app identifies itself as an API app. Web apps use their route inventory without repeatedly requesting the API-only plugin endpoint.

Inspect credential changes allow only one save at a time. While saving, token fields and removal controls are locked. A successful save clears the input fields; a failed save retains the edits so you can correct or retry them. “Configured” describes stored credentials, not a successful connection check. Configuration badges continue to follow fresh access observations after a save; changes made elsewhere do not discard unfinished token edits. Every failed save shows an error, including provider rejections without diagnostic text. Retrying successfully clears the error and saved input fields.

Analytics provider capabilities and recent activity are shown only for a successful current read. Loading and read errors have separate states; an unavailable snapshot is not presented as an empty or unconfigured sink. Once the read succeeds, the current provider and activity return.

The API analytics inspect endpoint is served by the common authenticated router in development and serve deployments. It reports the configured sink (including the default noop sink), its capabilities and recent analytics operations from that process. Missing analytics wiring produces an explicit unavailable response instead of an absent route.

Recent analytics activity counts completed executions of the configured sink’s track, aggregate, timeseries and topN operations, with their failures and durations. Other plugin hooks are excluded. Counts describe calls, not event delivery: the noop sink accepts track calls without storing events. Only fixed operation labels are recorded, never event names, subjects, tenant IDs or payloads.

The activity counter is labeled sink calls. In a combined replica view, each replica retains its own call counts and latency measurements, even when the replicas share one analytics database. Selecting a single replica shows only its operations. A failed read hides stale activity until a successful refresh restores it.

Aggregate refresh indicators are hidden while a read is pending or has failed. Retained snapshots never keep the Live indicator visible during a read failure; the original error message remains available, including errors returned as text.

Aggregate inspection and manual refresh use the shared authenticated inspect router in development and serve deployments. Reading requires inspect read access; refreshing requires write access. An unavailable aggregate registry reports an explicit unavailable response rather than a missing endpoint.

The Events panel distinguishes loading, failed reads and an empty event inventory. Pending or failed reads hide retained routes, counters, origin and live status. Read errors preserve the original message; after recovery, the expanded event remains selected.

HTTP RPC ingress receives trace context through the W3C traceparent header. The framework-provided Effect HttpClient forwards the active trace on outbound HTTP requests, and webhook ingress continues the received parent. An explicitly supplied outgoing traceparent is preserved. WebSocket RPC uses its protocol trace fields instead; placing those fields in an HTTP RPC envelope is not a replacement for the HTTP header.

Production stores are opened before observability plugins finish activating. Once the server tracer is ready, those stores use the same tracer for subsequent SQL and transaction spans, preserving the calling request’s trace context without reopening the database pool. Earlier boot-time operations are not retroactively captured.

With the inspect trace ring enabled, both development and production record subscription snapshot and delta deliveries under the subscription’s trace ID. Delivery latency measures producing and pushing that delivery; it is not the age of the open connection. The bounded ring reports only retained deliveries. Transport wrapper spans are omitted, so a visible span may reference a parent outside the displayed trace. Disabling trace capture does not disable subscription metrics.

When a detached subscription is successfully resumed within its replay window, later deliveries keep the original subscription trace and setup parent. Replaying a previously produced delta does not create another delivery span. If the old subscription has expired, the fallback snapshot belongs to the new subscription trace.

The waterfall shows elapsed time within the retained trace alongside each span’s own duration. Open a span to inspect its full name, parent ID and attributes. Trace and span disclosures work with the keyboard; focus the waterfall to scroll horizontally on narrow screens. Parent resolution prefers the same replica, then an unambiguous cross-replica parent. Missing, ambiguous or cyclic parent references do not create artificial deep nesting.

The Traces panel hides retained traces and counters during pending or failed reads, including after changing the error-only filter. Read failures are announced separately from an empty result and preserve the original error message. The filter stays selected across failure and recovery.

Trace snapshots are validated before rendering the waterfall. Invalid trace or span fields, timestamps and counts produce a read error instead of a broken or misleading trace. Refresh traces, when supported by the provider, retries without resetting the error filter, deep-linked trace or replica selection.

A trace deep link requests the selected trace ID before the 50-trace list limit is applied. It can therefore show an older trace that is still retained in the process buffer, including a background trace hidden from the normal list. An evicted trace cannot be recovered from that buffer.

The dashboard requests traceId=<id>&grouped=1 from the inspect endpoint to receive the grouped dashboard snapshot. A direct traceId=<id> request returns the individual spans.

Log read states

While a new log filter is loading, the dashboard hides records from the previous snapshot. A failed read displays its error without presenting stale records or an empty-result message. Filter settings remain selected through failure and recovery. Only a successful read with no matching records shows an empty result.

Timeline read states

The timeline distinguishes loading and failed reads from recording being disabled. Replay rows are shown only when the successful response matches the selected table and sequence. While a new replay loads or fails, the previous row set is hidden; it is never presented as a different historical state. Disabled or unavailable timeline reads do not trigger replay requests. Until the app is resolved and a replay position is selected, the host suspends the corresponding subscription and polling instead of sending placeholder app IDs.

Retained timeline history

The table picker follows the tables present in the retained events. If the selected table disappears after recording replacement or retention, the first available table becomes selected; an empty recording makes no replay request. A temporary loading interruption preserves the preferred table. Frozen positions still require an explicit "Jump to now" after their recording becomes unavailable.

SQL Server Change Tracking events carry netChange: true. They may combine intermediate writes and provide current row images or delete keys only. Timeline records this provenance and refuses historical reconstruction across these events, including inserts whose post-image appears complete; the marker does not restrict reactive query refreshes.

PostgreSQL Timeline uses a transactional source journal rather than relying on LISTEN notification images. Unsupported or oversized source images make history unavailable instead of allowing an approximate replay. The journal remains readable during a notification interruption; schema, lease and retention validation determine whether its history is continuous. See Time travel for preparation and limits.

In production, Timeline applies the data browser’s schema privacy policy before recording row images and again when returning events or replay rows. Columns marked .sensitive(), .encrypted() or .serverOnly() stay masked even when an older image replaces a current row. Undeclared columns and images of undeclared tables are withheld; protected tenant metadata is redacted too. Null values remain null. Native SQLite and PostgreSQL also mask schema-protected fields in development because their source journals persist images. Other development stores retain their existing schema visibility and sensitive-name redaction. A failed capture mask invalidates the history instead of recording the original payload.

If the process change tap cannot record an event, it clears the timeline and rotates its recorder identity instead of silently retaining incomplete history. Change delivery continues; later events start a new history. Frozen positions and in-flight replay from before the recording failure become unavailable, including when sequence numbers are reused.

For recorders fed by change callbacks, a proven store or broadcast gap clears history and rotates its identity before live queries refresh. Frozen positions before that gap become unavailable, even when later events reuse sequence numbers. Native SQLite and PostgreSQL journal sessions validate their own continuity: notification-only gaps still refresh caches and live queries, but do not discard complete source history. A replay whose history identity changes during its read returns HTTP 409. Use “Jump to now” after a genuine history loss; missing events are not reconstructed from current rows.

Replay refuses to cross an event whose required row image or scalar identity is missing and returns HTTP 409 instead of silently skipping that event. String and numeric id values retain their types during reconstruction; numeric 1 is distinct from string "1". This check does not prove that a present image is complete or that all external events have arrived.

Each timeline snapshot includes a recorderId. Replay requests must send that identity alongside table and seq; missing or replaced identities return HTTP 409 before reading rows. Sequence numbers are meaningful only within one recorder history. After a restart, a frozen dashboard selection becomes unavailable even when the new recorder reaches the same sequence number. “Jump to now” explicitly selects the new history, and late replies from the previous recorder remain hidden. History is in memory and is not restored across restarts.

A recorder counter check alone cannot synchronize a database snapshot with delayed external CDC delivery. Stores without coherent source capture retain that consistency limitation: an external change whose event has not arrived can affect replay. Native SQLite and PostgreSQL instead read source events and current table pages in one validated snapshot. This is bounded debugging history, not a durable audit log.

Replay accepts only non-negative integer sequences within the retained process-local history. An evicted or future sequence, disabled recording, or a recorder that advances while current rows are read returns a conflict instead of a reconstructed result. Refresh and select an available sequence; retry if recording advanced during the read. Sensitive field names are redacted in current rows as well as recorded changes.

Timeline recording and replay use the same inspect route under voltro dev, voltro serve and compiled production builds. Production recording stays off by default; enable it explicitly with VOLTRO_TIMELINE=interesting or all. Table reads use 500-row pages in one transaction. Native SQLite and PostgreSQL source sessions read those pages together with journal events; PostgreSQL tracks MVCC visibility so late commits are not skipped. Other stores use their existing transaction isolation, without a complete external change-history watermark. Preparing and retiring source capture belongs to schema maintenance, not serving.

If a pinned timeline sequence leaves the retained window or the process restarts with a lower sequence, replay stops and the dashboard explains that the position is unavailable. Use “Jump to now” to resume the current view. It does not silently substitute another historical position.

Migration action feedback

Applying a plan, consolidating history and restoring soft-dropped columns require migration-write capabilities in the dashboard. While one of these actions runs, the other migration writes are disabled. Failed actions display their error and can be retried; successful actions show confirmation and request a refreshed status when the host supports refresh.

Retained schema snapshots

The migrations view lists timestamped soft-drop tables and columns that are still present in the live schema, including their original name, stored name and timestamp. This inventory is visible with read-only access and is independent of the recent plan-history limit. A snapshot name does not identify a unique migration plan, so inventory entries do not imply a restore action or a verified plan association.

For environment comparison, enter the remote app URL with or without a trailing slash. Apps served under a path prefix and a complete /_voltro/inspect/migrations URL are also supported; the dashboard resolves the inspect endpoint without adding a duplicate slash.

When you repeat an environment comparison, its previous result disappears while the request runs and stays hidden if the request fails. Comparisons for other environments remain visible. A successful retry displays the newly fetched result.

The Fleet view distinguishes loading, read failures and valid observations. A pending or failed read does not display a previous snapshot as a current complete fleet. Once reading succeeds, answered, missing and stale replicas are shown from that response.

The Cluster view shows an instance count and coordination facts only after a successful read. Loading has its own status; a failed read displays the error without retaining old instances or claiming that the cluster is empty.

Cluster coordination counters report all running schedules and workflows and all retained schedule claims, independently of the 500-entry recent-schedule history window. Replica IDs from that history describe recent schedule activity, not current membership. SQL read failures surface as errors instead of zero counts.

Cluster capability labels include PostgreSQL, MySQL, MariaDB and SQL Server in the full tier. MySQL and MariaDB show binlog CDC and their per-replica server_id when CDC is enabled; SQL Server shows Change Tracking. Advisory-lock scheduling on these SQL stores is reported as advisoryLock, rather than single. Explicit single coordination and disabled CDC remain visible as configured. The CDC state in the app manifest and the Cluster panel follows the initialized store, not just the requested environment setting. Native CDC disabled because every app table is non-reactive is reported as off; no binlog server ID is advertised in that case. The Schedules and Cluster views report the effective scheduler coordination, including runtime fallbacks, rather than inferring it again from the database dialect. In development an explicitly selected SQLite advisory coordinator is therefore shown as advisoryLock.

MySQL and MariaDB declare the shared binlog offset table _voltro_cdc_offsets; SQL Server declares its Change Tracking variant. This schema remains declared even with CDC=0, so migration planning and application boot agree. When upgrading a MySQL deployment that lacks this table, apply the generated schema migration before starting the new production version. Each replica persists its own cursor for restart recovery.

Absent optional framework tables still produce empty results. This exception checks the underlying SQL cause; a generic statement-prepare failure alone is not evidence that a table is absent.

Overview telemetry

Overview, Logs and Metrics subscribe to the shared app registry. Address and read-token changes made in another browser tab are applied without reloading the current page; the old connection is replaced even when the app ID stays the same.

API apps publish completed HTTP responses to the overview in both voltro dev and voltro serve, including unsuccessful responses such as 404. Each response contributes one request, its status and elapsed time. Inspect endpoints are excluded to prevent dashboard polling from counting itself, and query parameters are omitted. HTTP streams count when they finish; aborted responses and individual WebSocket RPC messages are not completed HTTP responses.

The overview follows URL, read-credential and app-metadata changes even when an app keeps its ID. Unchanged observations keep their stream connections; reachability probes do not overlap. Latency charts ignore absent, non-finite or negative durations instead of treating them as 0 ms. Each minute retains up to 1,000 measured durations using uniform reservoir sampling, so percentiles are estimates across the whole observed minute rather than biased toward its latest requests.

Inspect events carry a replay-stable stream identity and sequence. The overview counts replayed requests and cache events only once after reconnecting. Identical simultaneous requests and events from another bus or a restarted process remain distinct. Older producers without a cursor cannot provide this replay deduplication.

Local migration actions

The local dashboard currently supports migration inspection and environment comparison. It does not provide migration rollback, plan application, history squashing or snapshot restoration. A missing rollback implementation is reported as unavailable, never as a successful rollback. Seed execution remains available when the app and access policy allow it.

For file migrations handled by voltro db rollback --to <id>, the target must already be applied. An unknown or pending target is rejected before any undo step runs. The target is included; omitting it rolls back only the latest applied migration.

This target check also applies when no migration files are found: specifying a target then fails, while a rollback without a target remains a no-op.

Inspect framework actions use the shared authenticated router in both boot modes. Seed execution and migration actions still require an implementation in the running app; routing an endpoint does not make an unsupported operation available. Write requests require the configured write credential in addition to read access.

The database panel lists discovered seeds in both development and serve mode. With write access, you can explicitly run a seed after confirming the action. This does not enable automatic production boot seeding. Failed execution is reported as an action error and retained in the seed status; a successful retry clears the previous failure.

Seed cards use the selected dashboard language for actions, lifecycle and result labels. Dates and numbers follow that locale, and row counts distinguish singular and plural. Long identifiers and error messages wrap within the card.

Manual seed inspection accepts an optional namespace alongside id in POST /_voltro/inspect/seeds/run. An onTenantCreate seed requires an explicit namespace. The inspector resolves a namespace-scoped store before executing steps; empty namespaces and stores without namespace isolation are rejected. Seed data and its execution ledger use the selected store. The dashboard confirmation selects an existing tenant namespace and shows the target before execution. A namespace is required for tenant-creation seeds; for other seeds an empty field explicitly selects the shared database. The local and shared Cloud hosts forward this selection.

Seed results identify the last reported execution target: a namespace, the shared database, or an unknown target when the producer did not report it. This is the latest reported run, not a separate execution history for each namespace.

GET /_voltro/inspect/database/namespaces returns the existing SQL namespace inventory with inspect read authentication. An available empty list differs from unsupported discovery; SQL errors return a failure rather than an empty list. Seed execution checks a selected namespace against the available inventory before running. The shared dashboard and both hosts expose this inventory as a namespace selector. An empty inventory, unsupported discovery and a failed inventory request are separate states. Unsupported stores retain explicit manual input; a failed request or a selection removed from an available inventory blocks tenant execution without hiding the rest of the database snapshot.

Database snapshots and namespace inventories are process observations: replicas can have different seed definitions, last-run results or attached namespaces. A combined replica selection therefore compares separate database panels. Seed actions target one selected replica through the inspect target route; they are never broadcast or silently redirected to the load balancer. The shared row editor remains a single editor.

Automatic boot, schema-change and cron seeds report the shared database as their execution target. Tenant-creation seeds report the specific tenant namespace, including failed runs. A successful retry replaces the previous error. These observations belong to the executing replica and show its latest reported run.

For in and not in, enter or paste comma-separated values. Commas, spaces and unfinished negative numbers remain visible while editing. Numeric lists must contain valid numbers before applying; the filter is sent only after Apply filters.

Data-explorer URLs preserve the selected page size together with the page, filters, search and sort. Reloading or sharing a link therefore retains the same page boundaries. Supported sizes are 25, 50, 100 and 250 rows; omitted or unsupported sizes use 50. Custom DataViewerUrlState bridges should round-trip the optional pageSize field alongside page.

Outbox response errors

Malformed queue or attempt-history responses show a read error instead of an empty state or a broken page. Use Load again to retry; valid queue entries and history reappear after recovery.

Outbox resend admission and replicas

The outbox queue and attempt history are shared records. In the local dashboard, select exactly one replica before requesting another attempt. That replica validates the registered handler and admits the request. A combined view remains readable but does not offer resend actions. An unavailable target causes an error; the dashboard does not silently retry against another replica.

Selecting the admission replica does not pin delivery to that process. Any eligible worker consuming the shared queue can claim the delivery.

Inspecting a connected process without fleet discovery

When fleet discovery is unavailable, the local dashboard keeps your replica selection unchanged. Open the replica selector to select the connected process identified by the authenticated app response, then apply the selection. You can inspect that process without configuring a shared replica registry first. The selector labels this as a connected process, not a complete fleet inventory; “All replicas” still requires discovery.

Finding a route in the hierarchy

The route tree search matches URL patterns and source-file paths, ignoring case and surrounding spaces. Matching routes retain their parent hierarchy and open automatically. Empty results hide unrelated route details. Clearing the search restores your previous expanded/collapsed branches and returns focus to the search field. The result count distinguishes matching routes from the complete inventory.

Opening an inspected web route

Route details include an Open page in new tab link when the host supplies the app address. Static routes open directly. For [id] and [...path] routes, enter the required parameters first; [[...path]] is optional. Separate catch-all path segments with /. Values are encoded for the URL, and empty or dot traversal segments are rejected.

The destination uses the registered app address and drops inspect query parameters and fragments. Changing the route or app address clears parameter drafts. This opens the app's public address; it does not pin browser traffic to the selected inspect replica.

Refreshing log snapshots

The page validates the snapshot and every log record before displaying them. Invalid timestamps, counters, record fields or causes produce a read error; previous records, counts and capture time are hidden. A valid response restores the view without resetting its filters or replica selection. Use Refresh when the provider offers it, or wait for its automatic retry.

When a log provider supports manual refresh, the shared log page offers Refresh. It reloads the current severity, scope, message and replica selection without resetting the filters. The button is disabled while a read is pending and remains available to retry a failed read. Failed reads hide both stale records and the previous buffer count. Automatic provider updates continue independently.

Reading structured log details

Severity labels and error summaries adapt their contrast to the light or dark theme. Compact filters leave more room for records; long details can be scrolled with the keyboard after focusing their detail area.

The log list shows a captured error's first cause line immediately. Expand Details for its complete captured cause/stack trace and structured fields. Large values stay inside a scrollable, keyboard-focusable detail area instead of stretching the entire page. Replica identity remains in the record header and is not repeated as a structured field.

Incoming snapshot records preserve the expanded state of an unchanged record. Log records have no durable wire ID; identical records use their occurrence within the current snapshot. The dashboard displays the cause supplied by the log buffer, not an uncaptured original error.

Log snapshot freshness

The local log page automatically checks again four seconds after each completed request, including failed requests. This is snapshot polling, not a live-tail stream or a guarantee that new entries arrive within four seconds. The page shows the server's capture time for a successful settled snapshot. Failed or pending reads do not present the previous capture time as current; failed local reads explicitly indicate automatic retry. Other hosts only show a polling interval when their provider declares one.

Local dashboard preferences

Under Settings, the theme can follow the operating system or stay light/dark. The preference survives reloads. The language selector has an accessible name and reloads the dashboard in English or German. Long registered app URLs wrap within the settings panel on small screens.

Clear all removes this browser's registered apps after confirmation. Cancelling keeps them. Server-configured apps return when you open Apps again; reloading Settings alone does not register them again. Runtime discovery remains independent of the saved browser registrations; removing a browser registration does not stop an app or delete its data.

In a locked dashboard, Sign out disables itself while the request is pending. A network or server error keeps the current view and shows a retry message. Only a successful server response closes the dashboard gate. The cleared session stays locked after reload; enter the dashboard token again to regain access.

If the dashboard cannot verify its session, it shows a connection error instead of opening the page. Check again repeats the session check without resubmitting the token. Failed login requests keep the entered token available for retry and distinguish connection problems from an incorrect token. A previously known lock remains closed when its session endpoint is unavailable or returns an invalid response.

App registrations supplied through VOLTRO_DASHBOARD_APPS are available in both voltro dev and voltro start. The dashboard config endpoint follows the dashboard session guard and exposes only whether read/write credentials are configured, never their values.

Runtime flag overrides, toggle audit and targeted usage observations use the configured durable app store. The flags plugin completes loading and starts usage tracking after both activation and store binding, including the early-activation order in voltro dev. A restart retains persisted overrides and observed usage; memory-only flags remain configuration-based.

Scope of flag changes

The flag controls distinguish the process whose values you are viewing from the scope of a toggle. Memory flags change only in that process and reset on restart. Durable flags persist in the shared data store: selecting one replica chooses the writer, not an isolated override for that replica. Other replicas reload the override through the configured change transport or on restart. A shared database alone does not guarantee that every running process has already reloaded it; use the replica comparison to inspect their actual states. Older apps that do not report write scope show an explicit unknown-scope note.

Restoring an inbox lookup

Submitting an inbox lookup stores the selected subject as subjectId in the notification page URL. The local dashboard and Cloud app inspector restore that inbox after reconnecting, replacing a replica, or reloading the page. Browser Back and Forward restore previously submitted lookups. Editing the input alone does not change the selected inbox; submit it to run the new lookup. Existing replica-selection parameters remain intact.

Delivery records show status, category, errors and click outcomes directly. Expand Show delivery endpoint to read or select the complete endpoint without long device addresses obscuring the delivery log. The disclosure also works with the keyboard.

The comments inspector keeps submitted search, thread-list position, selected thread and message-page position in the page URL. Reloading, remounting an inspection panel, or navigating Back/Forward restores that view. Searching or changing thread pages closes the old detail; clearing the search returns to the first thread page. Replica selection is preserved.

Thread details identify the selected thread and the source replica. Message timestamps follow the dashboard locale; an edited message also shows its edit time. Read failures hide stale message contents rather than presenting them as current.

The moderation inspector makes all retained reviews accessible in pages of 50. The plugin retains at most 200 reviews in process memory. Pending counts that retained queue; blocked and flagged are counters since process start. A restart clears the review queue and counters. Confirming a review records the decision; it does not delete content or block a subject.

The billing inspector shows configuration and pending usage reports, not subscription administration. used is cumulative for the period and reportedToProvider is the amount already reported; their difference is pending. A flush reports that difference without resetting usage. Rows disappear from the pending view when fully reported. Replica snapshots of shared storage are compared rather than summed.

A temporary failure to read the installed-plugin inventory hides and disables the affected plugin panel while preserving its existing search, pagination and form state. Once discovery recovers, the same panel returns. A successful inventory response confirming that the installation is absent removes that panel and its state.

Production data is read-only

The data explorer reflects the connected app’s supported operations. An app started with voltro serve exposes tables as read-only: searching, filtering, sorting, pagination and reference navigation remain available, while row creation, editing and deletion are not offered. A write token does not enable these unsupported production data routes. In voltro dev, editable application tables retain their data editing operations; framework-internal tables remain protected.

Changing the target app, endpoint or replica selection resets the RPC execution form, including its tenant choice, draft, confirmation and result. A late response from the previous target cannot populate the new target’s form. Switching targets does not cancel a request already sent to the server or undo its effects. Custom shared-dashboard hosts should supply RpcPage.invocationScope from stable app, endpoint and replica identity plus an opaque credential revision; never put credential values in the key.

The Environment panel shows presence and boot-satisfaction flags, never environment values, defaults or examples. Not set (allowed) means an unset variable does not block startup because it is optional or has a default; it does not claim that a default exists. A restarted process has a new replica identity. Select that identity to inspect its current presence flags; an ended selection is not silently treated as the restarted process.

Agent-tool details show the declared input schema, approval requirement and optional per-agent-run call limit. The displayed maxPerRun is not an MCP transport rate limit: an external MCP client must honor that declaration itself. The dashboard inventory does not execute tools or grant an execution subject from the Inspect credential.

Numeric filter inputs

Integer filters accept whole numbers within JavaScript's safe integer range (−9007199254740991 to 9007199254740991). Fractional or unsafe values are rejected by both the dashboard and Inspect endpoint instead of silently rounding them. Decimal filters keep exact strings: use a decimal point without exponent notation, and commas between list values. Invalid drafts show a correction hint and cannot be applied. This preserves the query input; it does not change the storage precision of the selected database dialect.

SQLite row queries and write results preserve declared bigint() values as exact strings, including values beyond JavaScript's safe integer range. Numeric sorting continues to use the stored integer rather than the displayed text. This change does not alter decimal storage affinity or raw SQL result decoding. Related rows loaded through SQLite JSON aggregation, including many-to-many junction fields, also retain bigint strings. Explicit join projections preserve them under renamed output keys; sorting still uses the original numeric column.

SQLite schema inspection distinguishes NUMERIC/DECIMAL columns from TEXT. An unchanged decimal declaration does not require a type migration. An actual change between these storage forms is treated as a potentially lossy migration and requires an explicit migration decision; it is no longer silently ignored. This distinction does not make SQLite NUMERIC storage exact.

Schema choices in filters

Columns with a declared oneOf list offer those values directly: select one value for equality or inequality, or check multiple values for in / not in. Longer lists are searchable. Commas and whitespace remain part of the selected value; an allowed empty string has its own labeled option. Saved filter values remain visible even if they are no longer declared in the current schema.

Switching from a list operator to equality keeps a single selected value. With multiple selections, choose one value before applying the filter. Switching to a null check clears the previous value.

Date and timestamp filters

Filters use the declared column type. Date and timestamp equality, range and list predicates normalize ISO values before binding them to the database. For timestamps, include Z or an explicit offset: 2026-09-29T14:00:00+02:00 and 2026-09-29T12:00:00Z identify the same instant. This also applies to nested filters. SQLite receives its encoded date representation rather than a JavaScript Date object.

The data explorer also receives live changes from apps started with voltro serve. Read-only access does not disable the CDC stream: changes observed by the configured store refresh the selected page, including external PostgreSQL writes when CDC is enabled. An open stream alone does not establish that a particular database adapter observes external writes; that depends on the store and its change-capture configuration. Production CDC row payloads use the same schema-aware masking as production timeline reads; protected fields remain masked and undeclared fields are omitted.

The data explorer provides one Clear search control. Clearing a search restores the unsearched result and returns keyboard focus to the search input, so you can immediately enter another query.

In the record editor, Choose linked row opens a searchable list. Keyboard users can search, Tab to a result and select it with Enter. Selection returns focus to the reference control while retaining the draft; the relationship is written when the record is saved.

Concurrent queued-start recovery

Admission history retains numeric millisecond waits beyond the 32-bit integer limit (about 25 days). The schema migration widens the existing waiting-time column; old numeric values and nulls remain available. This allows old queued starts to be admitted or discarded with their full elapsed wait recorded.

Queued-start recovery is separate from retrying an existing execution. When operators concurrently retry the same dead-lettered queued start, only the request that re-arms it reports a change. The inspector coordinates this decision with admission and discard; it preserves the queued payload and its original schema and release provenance.

Workflow definitions across replicas

Selected absolute time bounds apply to both the run list and its statistics. The Inspect statistics endpoint accepts startedAfter and startedBefore as ISO timestamps; explicit bounds take precedence over the relative window. With only an end specified, the relative window is measured back from that end. Invalid or reversed bounds return HTTP 400. The observation window includes its start and excludes its end. Totals, chart buckets, workflow/version summaries and latency samples use that same window. Runs timestamped at or after the observation end are excluded; they can enter a later refresh once its window reaches them. Sparkline tooltips use the loaded window's timestamps, including historical windows, rather than the browser's current time. When a workflow filter finds no runs, the filter controls and saved views remain available. Saved views restore their filters after a reload and clear absolute time bounds when applied. The view controls explain this reset. If browser storage rejects a save or deletion, an error remains visible and the existing views and name draft remain unchanged; retry after storage becomes available. Window labels show the observed duration without calling historical ranges “last” or rounding 90 minutes to two hours.

The shared workflow dashboard, including each workflow’s detail page, retains available workflow definitions when another selected replica does not answer. The definition notice identifies incomplete results and lets you inspect the answering replicas separately. Different schemas or registrations are kept per replica and excluded from the shared definition selection; select a specific replica to inspect that definition. Missing responses never count as a complete fleet result.

Inference queue pages

Offloaded inference lists have independent Previous/Next controls for waiting and recently completed calls. Counts cover the retained queue, not only the displayed page; long-wait and expired-lease counts are also calculated across the queue. The Inspect endpoint accepts limit (1–200), queuedOffset, and recentOffset (nonnegative integers), and returns page totals. Ordering uses the timestamp and row identity so equal timestamps do not shuffle between page reads. Live writes can change page membership; the displayed totals reflect the latest read.

Inference queue elapsed time uses the immutable original enqueue timestamp. waitingMs is null when that timestamp was not recorded; custom consumers must show unknown timing rather than zero. Such waiting jobs follow known ages in ID order and are excluded from the long-wait count; counts.unknownTiming reports their number. Completed rows show total elapsed time, while durationMs remains the provider-call measurement. Provider polling and retry delays do not reset age.

Workflow start forms load their payload schema from the connected write gateway, independently of the replica selected for inspection. The form identifies that distinction; selecting a peer does not pin workflow execution to it. If the gateway definition is loading, missing or unavailable, submission is disabled. A temporary read failure keeps the existing draft while preventing submission. Custom shared-dashboard hosts supply WorkflowsPage.useStartDefinitions from the same logical endpoint used by useStartRun, without forwarding replica read selection. The server still validates each submission; a deployment change between reading and submitting can reject an outdated payload.

The shared start dialog saves a caller-owned request: { id, at } before sending the start request. If browser storage fails, it sends nothing. After an unknown delivery, the saved identity survives reload; an explicit retry reuses its ID and original timestamp. Reloading or changing the selected replica never sends another start automatically. Only identity metadata is stored, never the workflow payload or credentials; re-enter the same payload after reload.

Start providers must forward the request metadata unchanged to Inspect. The local provider and both Cloud proxy authorization paths preserve it. A confirmed HTTP 400, 401, 403 or 404 rejection is returned as { kind: 'rejected', status, message }; conflicts, server failures and network failures remain errors with unknown delivery. A rejection clears only a fresh request, never a previously unresolved delivery. Once a receipt is observed, the dialog can recover without receiving the original POST response. Receipt reads begin after the current delivery attempt settles. Changing the inspected app closes its start dialog. A delayed success, rejection or transport error remains associated with the original app and cannot close a new app's dialog or change its draft. Returning to the original app observes its saved request without automatically submitting it again. If several unresolved requests exist for one workflow, the dialog lists their full request IDs and tenants. Choose the intended request explicitly, then enter its original payload. Continuing preserves that request's ID, timestamp and tenant; the tenant cannot be edited. Changing the selection clears the payload draft so it cannot accidentally be sent for another request. Keyboard focus starts on the request choices. A single saved request is selected automatically, but still requires its payload after reload. If observation resolves the selected request while the dialog is open, the dialog closes rather than turning into a new-start form.

Workflow recovery is bound to both the app and its mutation gateway. Changing a registered app's server address does not send its saved start, retry, restart, cancel or resume identities to the replacement endpoint. Returning to the original address restores that journal. Replica observation selection and separately supplied credentials do not create another gateway identity.

The local and Cloud workflow list, detail and run routes use the shared WorkflowGatewayBoundary with the logical app ID and actual app gateway URL. Custom hosts should use that boundary and pass its resolved scope as controlScope; do not use a replica-decorated proxy URL as the gateway. Credentials in the URL or unrelated query parameters are rejected instead of being persisted in recovery keys.

Older journals lack server provenance. Before any of their recovery readers mount, the dashboard shows their IDs and asks you to confirm the original gateway. Close older dashboard tabs before associating those records. If the displayed address is wrong, restore the original app address first. Association copies identities into the gateway-bound journal without deleting originals or overwriting different existing entries. The association is published only after the copies succeed; a storage failure keeps the review gate closed and allows a retry. A browser Web Lock serializes association across current dashboard tabs. This association does not itself send a workflow command.

The workflow start dialog focuses the payload editor when its schema is ready. Tab moves through its fields and actions without activating background page controls. Escape or Cancel closes an idle dialog and returns focus to the invoking button. While a start request is pending, dismissal and duplicate submission are blocked; failed requests retain the draft.

Send-event and replay dialogs use the same keyboard navigation and focus restoration. A pending emission blocks dismissal and duplicate sends. The receipt stays open for review and focuses Close; the same dialog cannot resend an accepted event.

Signal and update dialogs also focus their named input and support Escape with focus restoration while idle. Pending requests block dismissal, field edits and duplicate submission. Update results stay visible and focus Close. A sent signal remains visible while consumption is unconfirmed; it is no longer hidden after a fixed timeout. A matching received-signal event confirms consumption before the dialog closes.

Server-side engine diagnostics can use readWorkflowRunReply(workflow, executionId) from @voltro/workflow/cluster with the same engine’s Sharding and MessageStorage services. It returns not-found, pending (a request exists without a terminal reply), or reply with string request/reply identities and the encoded Exit. Unlike workflow.poll, this reader does not decode the reply as a workflow result: an outer delivery failure such as MalformedMessage remains inspectable even when no run row was recorded. Storage failures remain errors. The reader never acknowledges, resets or dispatches messages. This is a server diagnostic primitive, not automatic dashboard integration; authorize and project its raw reply before exposing it to clients. A stored reply alone does not prove recorder entry or execution success.

The read-only Inspect endpoint GET /_voltro/inspect/workflows/execution?workflowName=…&executionId=… observes an accepted execution even when no run row exists. It requires Inspect read authorization and validates the retained execution placement before reading the engine. The response contains only the requested identities and not-observed, pending, delivery-failed, suspended, or completed (with succeeded, failed, or cancelled). It does not expose payloads, outputs, raw causes or journal IDs. Missing journal evidence does not prove a start never happened; a storage or placement failure returns an unavailable observation instead. This endpoint does not start, retry or pin execution, and the status does not prove recorder entry. The shared dashboard retains accepted execution IDs and observes them independently of the run list.

Local and Cloud dashboard observation providers validate the returned workflow and execution identity. Accepted-start observation stays at the start gateway when the inspection replica selection changes; it does not retarget or repeat the start. Invalid or foreign responses remain read errors, not successful execution evidence.

Accepted starts remain visible after reload and inspection-replica changes. Status refresh is read-only and never resubmits the start. Read errors preserve the last visible observation with an unavailable warning. If browser storage fails, the accepted ID remains visible in the open page and the dashboard warns that reload recovery is unavailable; it does not reopen submission as a failed start. Completed execution or delivery-failure observations can be dismissed after a current matching read. Lost start responses are not covered by this recovery view.

Workflow definitions, domain events and expanded event deliveries retain their last successful snapshot within the same inspected app and replica scope. A failed or pending read is shown explicitly; it does not become an empty list or a zero tab count. Incoming traffic is only reported empty once both run and event reads are current. Event replay is unavailable while the event snapshot is stale, and returns after a successful refresh. Incomplete definition observations never establish that no workflows exist.

Workflow definition metrics distinguish missing observations from zero. Without statistics, historical run counts and trends show an em dash; the dashboard never derives a historical trend from the loaded run list. Running in loaded results counts only running entries in that list, not queued entries or the full fleet. Without a run observation that count is also unknown. Retained values remain qualified by their snapshot freshness notice.

Queued start handles can be observed through read-only GET /_voltro/inspect/workflows/queued-start?workflowName=…&receiptId=…. Supply the original tenantId for a tenant-scoped start; omit it for a global operator start. The endpoint uses the runtime’s durable start-receipt resolver and returns pending, accepted with a real execution ID, or not-executed with an admission outcome. Missing or contradictory evidence is an unavailable observation, never a fabricated pending run. Reading neither resubmits the start nor advances admission.

The shared dashboard also retains received queued receipts with their original workflow and tenant identity. They remain visible after reload and inspection-replica changes. Once admitted, the same receipt displays the actual execution and its read-only status. A queued receipt can be dismissed only after a current matching terminal admission result or execution result. Pending or unavailable observations cannot be dismissed; storage failures retain the receipt in the open page with a reload-recovery warning. This does not recover a start whose response was never received.

If saved views cannot be read, or stored entries are malformed, the dashboard keeps their stored contents untouched and disables saving and deleting. Filters remain usable. Retry loading views reads them again without discarding the name draft and returns keyboard focus to the view-name field. Every save or delete re-reads the current stored list first, preserving views added since the page loaded. This does not provide an atomic transaction across browser tabs.

Unresponsive Inspect entry points

The local dashboard can read through a recently observed, authorized peer when its original Inspect entry point stops responding. If another allowed peer is available, a read attempt that sends no response headers within two seconds gives way to that peer. The final attempt remains subject to caller cancellation; this is not a total request timeout. Once headers arrive, streaming response bodies are not subject to the failover timer. HTTP errors remain authoritative, cancelled requests stop, and writes are never automatically retried. Unknown, stale or disallowed peers are not used.

SQLite replica rebalancing

With SQLite-backed SQL runner storage, including remote libSQL, workflow shard releases are admitted one at a time per runner. Joining or restarting a replica therefore does not enqueue hundreds of shard-release writes simultaneously ahead of dashboard reads and application writes. Waiting releases can be cancelled, and a failed release frees admission for the next one. Other database operations retain their normal concurrency.

IPv6 replica addresses

POD_IP and VOLTRO_INSPECT_ADVERTISE_HOST may contain an IPv6 literal. API development, API production and web replica discovery publish it as [address]:port, using the bound application's port. Already bracketed literals are not bracketed a second time. IPv4 addresses and DNS hostnames keep their usual host:port representation. Advertising an address does not create network reachability: the peer still needs a listener and a permitted route to that address.

Updating custom dashboard adapters

Custom buildClusterInspect callers pass the effective runtime coordination instead of useClusterCron and scheduleCoordChoice. Preserve the initialized runnerStorage and store changeScope; database capability alone does not establish the active configuration.

WorkflowsPage.useStartRun returns WorkflowStartResult, including confirmed InspectCommandRejection outcomes. Use isInspectCommandRejection from @voltro/protocol/inspect before reading successful-start fields. Keep uncertain delivery as an error and forward the optional request.id and request.at unchanged on retry. The shipped local and Cloud adapters already follow this contract. voltro update provides manual migration guidance for custom hosts.

Creation retries

Upgrades crossing 0.84.0 include a manual Inspect creation-contract notice, including upgrades from 0.83.1. Review custom callers and dashboard providers using the contract below; voltro update does not rewrite them automatically.

POST /_voltro/inspect/data/rows requires { requestId, table, row }. Allocate the request ID once per intended creation (16–128 letters, digits, underscores or hyphens; a UUID works), independently of row contents. A retry of the same identity and input returns the existing creation receipt; a different input with that identity returns HTTP 409. Distinct IDs permit intentional identical creations.

The response contains receipt: { requestId, rowId, replayed } and row. The row is a current observation, not the original post-image: it may have changed or be null after deletion. Replaying never overwrites or resurrects a record. Creation and its metadata-only receipt commit in the same transaction. The protected _voltro_inspect_create_receipts table participates in normal schema planning.

The shared data explorer in the local and Cloud hosts persists table/request identity before sending a creation, without storing row values or credentials. After closing the dialog or reloading, it observes the result without automatically sending the row again. A confirmed creation can be opened and acknowledged; an unknown attempt can be withdrawn atomically, which never deletes an already created record. New creation in that table remains unavailable until the outcome is acknowledged. Browser storage and Web Locks must be available. The current dialog retains its original submitted values: retrying changed values is refused until the old attempt is resolved. DataViewerPage.useInsertRow receives { requestId, table, row } and must return DataCreationResult containing the matching receipt, not void. Both adapters forward the identity unchanged and return the receipt.

Creation recovery also has two development Inspect endpoints. GET /_voltro/inspect/data/rows/creations/:requestId?table=... needs read access and returns { requestId, table, kind }, where kind is not-observed, withdrawn, or created (also including rowId). It returns no row payload. not-observed does not prove that an in-flight request cannot still commit. Storage failures remain errors rather than absence.

POST /_voltro/inspect/data/rows/creations/:requestId/withdraw?table=... additionally requires the write credential. It competes atomically with creation: if withdrawal wins, a later create with that identity is refused; if creation already committed, it returns created and never deletes the record. Repeating withdrawal preserves the terminal result. Both dashboard hosts connect these endpoints to the shared persistent recovery controls. Cloud forwards the same identity through its tenant-authorized Inspect proxy; observation stays at the mutation gateway regardless of read-replica selection.

For custom dashboard hosts, @voltro/devtools-ui exports DataCreationReference, DataCreationObservation, DataCreationResult, validateDataCreationObservation(reference, response) and dataCreationScope(appId, gateway). Validate observations against both table and request identity before showing a terminal result. The scope uses the inspected app and mutation gateway; changing read replicas does not change it. These helpers do not activate persistent recovery in DataViewerPage by themselves.

Custom hosts enable persistence through DataViewerPage.creationRecovery: provide a stable scope, useObservation(reference) returning a DataSource<DataCreationObservation>, and useWithdraw() returning a mutation source for the same reference and observation. Reads must target the same mutation gateway as creation. Terminal outcomes are matched to both table and request identity. Providers without this option retain only the open-dialog retry identity.

Record dialogs distinguish an unconfirmed save or deletion from a confirmed result. A transport failure can follow a committed write. The dialog retains the draft and its original compare-and-set values, requests a fresh table observation, and keeps transport details expandable. Retrying does not adopt newly observed values as its expectation: an intervening edit, or a deleted record recreated with changed values, causes a conflict rather than being overwritten or deleted. Closing the dialog does not undo a stored change; reopen the row to inspect current values.

Late record-save, record-delete and bulk-delete responses update only the original view session. Returning to the same app after visiting another does not revive an old session. A bulk success retires only the submitted selection; it does not clear a newer selection. An unconfirmed bulk deletion keeps its original selected rows and expected values for explicit retry, requests a fresh observation, and explains the uncertainty. A conflicting retry preserves the entire batch rather than deleting its still-matching subset.

Data explorer result counts

Exact result counts use a store-side COUNT with the same search and filters as the visible rows. The dashboard no longer reads every matching row ID to calculate the total. Page size and offset do not limit the count. When no count is requested, only the page is queried; an estimate request still returns an exact count and reports it as exact. Counting and reading the page are separate observations, so concurrent writes can change the result between them.

The read-only creation-outcome observation is also available in voltro serve, so an existing creation receipt can still be checked after changing boot mode. This exposes receipt metadata, not a cached row, and does not enable production row creation or withdrawal.

Global log display and replay

The top-level Logs page keeps the latest 500 captured events across reachable apps in arrival order. Pause freezes the display while reception continues; Resume shows the current bounded buffer. The paused status counts new arrivals, including entries that may have aged out of the 500-entry buffer.

Reconnect replays are deduplicated by app, process stream identity and sequence. Identical messages from distinct events remain distinct. Clear removes captured rows without resetting replay cursors, so reconnecting does not immediately restore cleared records. Changing filters, pausing or discovering another app does not reopen unchanged app subscriptions. Interrupted streams show recovery status while retaining captured logs.

A selected app stays selected and named when it becomes unreachable, including after Clear. The page identifies unavailable sources instead of silently switching the filter; choose All apps to see healthy peers. New arrivals follow the bottom only while you are already there. Scrolling up preserves your reading position.

Global invocation metrics

The top-level Metrics page refreshes each reachable app independently, two seconds after its previous request completes. A slow or newly discovered app does not clear or delay healthy peers. Failed sources show their own error and retry automatically; their old values are not presented as current. Endpoint or credential changes discard the previous observation and cancel its pending request. Counts retain their source time basis and are not a fleet total.

API invocation snapshots include instrumented mutations, actions, workflow starts and plugin operations. A query execution does not by itself add an invocation to this snapshot; an empty snapshot is not proof that no queries ran. The global page states this limit and links to each app’s full metric registry. Window-based counts and cumulative registry counts remain separate rows even when their operation names match. Unknown latency is shown as —, never as zero; sorting places it after measured values. Malformed snapshots are rejected per source with automatic retry, while other sources remain usable. The shared isInvocationMetricsSnapshot validator is exported by @voltro/devtools-ui for dashboard adapters.

App-list reachability

The Apps list checks registered and discovered apps through their Inspect metadata endpoint. A runtime registry entry alone is not proof that Inspect access works. Each app is checked again five seconds after its previous probe completes; failed apps can recover without reloading the page. Adding another app does not reset healthy peers. Changing the endpoint or read credential cancels the old probe and ignores its late response. An app without known metadata or a registry type is marked Unknown type and is not counted as a web app.

Remove registration removes only this browser’s saved entry. A still-running app discovered by the dashboard remains listed. Its server-held Inspect credentials continue to work; the access dialog identifies browser credentials as overrides and separates field labels from their descriptions.

Single-app overview recovery

The overview inside an app reads metadata, routes, cache, RPC definitions and invocation metrics independently. A failed observation reports its error without hiding healthy sections. Reads retry automatically; Refresh overview retries immediately. Changing the selected app, endpoint or read credentials cancels obsolete reads, and late replies cannot replace the current app’s content. Temporary metadata failures preserve the last known app type and unfinished RPC input.

The live event feed retains up to 200 events during reconnection and ignores replayed sequence numbers from the same process. Identical new events and events from a restarted process remain visible. Invalid event dates are ignored. Invocation counters without duration measurements show a dash for latency rather than an invented zero or NaNms.

The event channel selector includes channels observed in the feed. If a filter has no retained events, Show all events restores the full feed. Each event payload can be expanded with mouse or keyboard; timestamps explicitly use UTC. The invocation summary labels either its rolling time window or its cumulative basis. Rerendered static counts are not presented as growth trends.

For an unknown or no-longer-discovered app, the inspector distinguishes an ongoing lookup, an unavailable app and a failed discovery read. Each state keeps a link back to Apps. Discovery retries automatically, so an app that returns can restore its inspector without reloading. A discovery failure retains previously known registrations instead of claiming that the registry is empty.

The app overview route filter includes SPA alongside static, SSR and ISR routes. Route metadata and cache hints can be focused with the keyboard. Cache and invocation tables expose labelled, keyboard-focusable scroll regions; headers and metadata labels follow the selected language. Dynamic route links use the shared parameter form before opening a concrete URL.

A production web app without a replica discovery source cannot provide a complete fleet inventory. In the replica selector, choose Only for the authenticated connected process, then Apply selection, to inspect it explicitly. All replicas is not silently reduced to that one process.