> ## Documentation Index
> Fetch the complete documentation index at: https://docs.synq.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Scout CLI reference
> Every synq-scout command, argument and flag, generated from the CLI itself.
This page is generated from the `synq-scout` command tree, so it always matches
the released binary. For what Scout does and how to deploy it, see
[Scout AI](/scout/scout); for using its tools from an MCP client, see
[Scout MCP](/scout/mcp).
Scout investigates your data: it triages issues, works out what changed and
suggests tests, using your warehouse and your Coalesce Quality workspace.
It runs three ways, and the same tools back all of them:
```bash theme={null}
synq-scout agent # long-lived, works tasks as they arrive
synq-scout mcp # an MCP server, for Claude Code or any MCP client
synq-scout tools list # each tool as a command you can run yourself
```
Scout only ever connects outward, so it can sit inside your network with nothing
exposed. Run `synq-scout health` after configuring it, and
`synq-scout auth login` to authenticate as yourself rather than with a
client secret.
With no subcommand, Scout runs the agent.
## Commands
### `synq-scout agent`
Run the Scout agent, working tasks from Coalesce Quality
```bash theme={null}
synq-scout agent [flags]
```
Run Scout as a long-lived agent.
It connects out to Coalesce Quality, picks up tasks as they are created, and
works them against your warehouse — nothing needs to reach in from outside your
network. This is the mode the container runs by default, and the mode an
on-premise deployment uses.
Database connections are validated on startup so a bad credential fails here
rather than midway through a task; --require-valid-connections turns a partial
failure into a refusal to start.
| Flag | Type | Default | Description |
| ----------------------------- | ------ | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | — | Dry-run mode: silently drop Coalesce Quality gRPC calls that are not NO\_SIDE\_EFFECTS (writes/mutations return empty without reaching the backend). Read-only calls pass through. |
| `--require-control-plane` | `bool` | — | Fail agent startup if cannot get config from Scout AI control plane (default: false) |
| `--require-valid-connections` | `bool` | — | Fail agent startup if connection validation fails (default: false) |
| `--validate-connections` | `bool` | `true` | Validate database connection connectivity on startup (default: true) |
### `synq-scout auth`
Manage Coalesce Quality API authentication
```bash theme={null}
synq-scout auth [flags]
```
Manage authentication for the Coalesce Quality API using OAuth2 authorization
code flow with PKCE. Credentials are cached under \~/.synq/oauth/, partitioned by
region, and shared with the other Coalesce Quality CLIs by default.
Pick a deployment with --region, or point at a staging or self-hosted deployment
with --synq-endpoint.
Examples:
```bash theme={null}
synq-scout auth login
synq-scout auth login --region us
synq-scout auth login --isolated
synq-scout auth status
synq-scout auth logout --region us
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | -------------------------------------------------------------------------- |
| `--auth-profile` | `string` | — | Credential profile to read or write (default: the shared profile) |
| `--region` | `string` | — | Region to authenticate against (au, eu, us) |
| `--synq-endpoint` | `string` | — | API endpoint, for staging or a self-hosted deployment (overrides --region) |
#### `synq-scout auth login`
Authenticate with Coalesce Quality in a browser
```bash theme={null}
synq-scout auth login [flags]
```
Authenticate using the OAuth2 authorization code flow with PKCE.
Opens a browser, then caches the resulting credential under \~/.synq/oauth/. The
login asks for the permissions synq-scout's tools need, not everything your
account could grant — a tool whose permission is not granted is left out of the
MCP tool list rather than failing when called.
By default the credential goes to the shared slot, so one login serves every
Coalesce Quality CLI on this machine. Pass --isolated to give synq-scout its own
credential instead.
Examples:
```bash theme={null}
synq-scout auth login
synq-scout auth login --region us
synq-scout auth login --synq-endpoint developer.synq.dev:443
```
| Flag | Type | Default | Description |
| ------------ | ------ | ------- | ----------------------------------------------------------------- |
| `--isolated` | `bool` | — | Store a credential for synq-scout alone instead of the shared one |
#### `synq-scout auth logout`
Remove the stored credential for a region
```bash theme={null}
synq-scout auth logout
```
Delete the cached credential for one region, leaving credentials for other
regions in place. The OAuth client registration is kept, so logging back in does
not create another connected app.
#### `synq-scout auth status`
Show every stored credential, for every region
```bash theme={null}
synq-scout auth status
```
List the cached credentials across all regions, with the workspace, granted
permissions and expiry of each. Reads local files only — no network calls.
Pass --region or --synq-endpoint to show one deployment instead of all of them.
#### `synq-scout auth token`
Print the access token, refreshing it if needed
```bash theme={null}
synq-scout auth token
```
Print the current access token to stdout, refreshing it first if it has
expired or is close to expiring.
Useful for scripting:
```bash theme={null}
curl -H "Authorization: Bearer $(synq-scout auth token)" ...
```
#### `synq-scout auth whoami`
Show who you are authenticated as and which permissions are granted
```bash theme={null}
synq-scout auth whoami
```
Call the Coalesce Quality IAM API and print the current identity, workspace
and granted permissions. Uses the standard credential resolution (client
credentials, then a pre-issued token, then the browser login).
### `synq-scout health`
Check that Scout can reach everything it needs
```bash theme={null}
synq-scout health
```
Verify this deployment's configuration.
Loads the config, fetches this deployment's settings from the Scout control plane
(which confirms both credentials and reachability, and reports the workspace it
resolved to), and sends a trial prompt to every configured model. Warehouse
connections are listed as discovered, not connected to.
Exits non-zero if the control plane or any model is unreachable, so use it after
a configuration change, or as a container health check, and a bad deployment
fails visibly rather than on its first task.
### `synq-scout issue`
```bash theme={null}
synq-scout issue [flags]
```
Triage one or more issues by their IDs. Multiple issues can be specified using --issue-id flag multiple times.
| Flag | Type | Default | Description |
| ----------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Dry-run mode: silently drop Coalesce Quality gRPC calls that are not NO\_SIDE\_EFFECTS (writes/mutations return empty without reaching the backend). Read-only calls pass through. |
| `-f`, `--ignore-status-check` | `bool` | — | Ignore status check of issue and do the triaging |
| `-i`, `--issue-id` | `stringArray` | — | Issue ID to triage (can be specified multiple times) |
| `-p`, `--prompt` | `string` | — | Extra prompt |
### `synq-scout mcp`
Serve Scout's tools to an MCP client over stdio
```bash theme={null}
synq-scout mcp [flags]
```
Run Scout as an MCP server, speaking the protocol on stdin and stdout.
Point any MCP client at it — Claude Code, Claude Desktop, Cursor — and Scout's
tools become available in that client, running against your own warehouse and
Coalesce Quality workspace. The same tools are individually invocable from a
shell with `synq-scout tools`.
Because stdout carries protocol frames, all logging goes to stderr.
| Flag | Type | Default | Description |
| ----------------- | ------ | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | — | Dry-run mode: silently drop Coalesce Quality gRPC calls that are not NO\_SIDE\_EFFECTS (writes/mutations return empty without reaching the backend). Read-only calls pass through. |
### `synq-scout sre`
Triage open issues once, now
```bash theme={null}
synq-scout sre [flags]
```
Run one triage pass over open issues and exit.
This is the same work the agent does continuously, invoked on demand — useful to
try Scout against your data before deploying it, or to re-run triage after
changing configuration. Narrow it to particular issues with --issue-ids;
with none, every open issue is considered.
Triage normally skips an issue whose status says it has been handled already;
\--ignore-status-check triages it regardless.
Note --dry-run defaults to true here, so nothing is written back until you pass
\--dry-run=false. To triage specific issues by id, `synq-scout issue` is the
narrower command.
| Flag | Type | Default | Description |
| ----------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Dry-run mode: silently drop Coalesce Quality gRPC calls that are not NO\_SIDE\_EFFECTS (writes/mutations return empty without reaching the backend). Read-only calls pass through. |
| `-f`, `--ignore-status-check` | `bool` | — | Ignore status check of issue and do the triaging |
| `-i`, `--issue-ids` | `stringSlice` | — | Issue IDs to conclude |
### `synq-scout tester`
Suggest data quality tests for tables
```bash theme={null}
synq-scout tester [flags]
```
Run one pass of test suggestion and exit.
Scout inspects the tables you name, and proposes tests appropriate to what it
finds in them. Restrict it to particular tables with --table-fqn, repeated per
table; a table is identified by its fully-qualified name.
Note --dry-run defaults to true here, so suggestions are reported without being
created until you pass --dry-run=false.
| Flag | Type | Default | Description |
| ----------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Dry-run mode: silently drop Coalesce Quality gRPC calls that are not NO\_SIDE\_EFFECTS (writes/mutations return empty without reaching the backend). Read-only calls pass through. |
| `-f`, `--ignore-status-check` | `bool` | — | Ignore status check of test suggestion state |
| `-t`, `--table-fqn` | `stringSlice` | — | The table FQN to suggest tests for |
### `synq-scout tools`
Inspect and invoke Coalesce Quality Scout MCP tools directly from the CLI
```bash theme={null}
synq-scout tools
```
Expose the same tools the MCP server serves as one-shot CLI commands.
```bash theme={null}
synq-scout tools list list available tools
synq-scout tools describe show a tool's description and schemas
synq-scout tools -- invoke a tool via typed flags
synq-scout tools --json '{...}' invoke a tool via a raw JSON argument object
```
Arguments can be supplied either as individual --\ flags (derived from the tool's
input schema) or as a single --json object, but not both at once.
#### `synq-scout tools add_comment`
```bash theme={null}
synq-scout tools add_comment [flags]
```
Post a Markdown comment on either an issue or an incident. The comment is
attributed to the calling user. Use this to record context, hand-off
notes, or reasoning about the current state so other engineers (and
future runs of this agent) can follow the thread.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--body` | `string` | — | \[required] Markdown-formatted comment body. Newlines and standard Markdown syntax (headings, lists, code blocks, links) are rendered in the UI. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--target` | `string` | — | \[required] The issue or incident the comment should be attached to. (JSON) |
#### `synq-scout tools batch_entity_details`
```bash theme={null}
synq-scout tools batch_entity_details [flags]
```
Get details for multiple entities identified by entity\_ids.
Use this when you need to retrieve information for several known entities at once.
More efficient than multiple GetEntityDetails calls when working with multiple entities.
Each returned Entity includes `table_metrics` when available — use it to gauge the size
and freshness of upstream/downstream tables before issuing queries against them.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools batch_executions`
```bash theme={null}
synq-scout tools batch_executions [flags]
```
Get detailed information for specific executions by their IDs.
Use this when you have execution IDs and need full details about those specific executions.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--execution-ids` | `stringArray` | — | Execution IDs to retrieve (max 20) |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools batch_urls`
```bash theme={null}
synq-scout tools batch_urls [flags]
```
BatchUrls generates Coalesce Quality application URLs for multiple entities, issues, incidents, dataproducts, and owners.
This tool translates IDs into properly formatted URLs that
can be used to navigate directly to the corresponding pages in the Coalesce Quality web application.
Usage:
* Provide entity\_ids to get catalog URLs for data entities (tables, views, etc.)
* Provide issue\_ids to get incident management URLs for specific issues
* Provide incident\_ids to get incident detail page URLs
* Provide dataproduct\_ids to get product page URLs for dataproducts
* Provide owner\_ids to get owner settings page URLs for owners
* All arrays can be provided simultaneously
| Flag | Type | Default | Description |
| ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--dataproduct-ids` | `stringArray` | — | List of dataproduct identifiers to generate product page URLs for. Accepts either a UUID or a prefixed form (e.g. "dataproduct-\{uuid}"). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | List of entity identifiers to generate catalog URLs for. IMPORTANT: Entity IDs always contain "::" separators (e.g. "ch-prod::default::runs"). Do NOT pass database FQNs like "default.runs" — use the full entity ID with "::" separators. |
| `--incident-ids` | `stringArray` | — | List of incident identifiers (UUIDs) to generate incident detail page URLs for. |
| `--issue-ids` | `stringArray` | — | List of issue identifiers to generate incident management URLs for. Accepts either a UUID or a prefixed form (e.g. "issue-\{uuid}"). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--owner-ids` | `stringArray` | — | List of owner identifiers to generate owner settings page URLs for. Accepts either a UUID or a prefixed form (e.g. "owner-\{uuid}"). |
#### `synq-scout tools browse_folders`
```bash theme={null}
synq-scout tools browse_folders [flags]
```
Browse the hierarchy one level. With no parent\_folder\_entity\_id, returns the
roots (top-level integrations / containers). With a parent, returns that
folder's direct sub-folders and the entity ids of its direct, non-folder
members. One level per call — browse each returned sub-folder in turn.
| Flag | Type | Default | Description |
| --------------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--parent-folder-entity-id` | `string` | — | Opaque id of the folder to browse into (a folder\_entity\_id from any FolderNode returned by browse\_folders, folder\_of, or an entity lookup). Omit to browse the roots. |
#### `synq-scout tools create_incident`
```bash theme={null}
synq-scout tools create_incident [flags]
```
Create a new incident grouping one or more issues under a shared name so
the team can track the combined investigation in one place. Use this when
the user is escalating a set of related issues that warrant a coordinated
response.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--group-ids` | `stringArray` | — | Issue groups to attach to the new incident (all member issues will be included). At least one of 'issue\_ids' or 'group\_ids' must be provided. |
| `--issue-ids` | `stringArray` | — | Issues to attach to the new incident. At least one of 'issue\_ids' or 'group\_ids' must be provided. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--name` | `string` | — | \[required] Human-readable name describing the incident. Keep it concise and specific — it will be shown in lists and notifications. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools create_monitors`
```bash theme={null}
synq-scout tools create_monitors [flags]
```
CreateMonitors creates one or more custom monitors. Ids are assigned
deterministically, so re-running an identical create is idempotent.
If unsure which check type fits the goal, call describe\_check\_types first.
For plain DWH TABLES, prefer create\_table\_stats\_monitor (reads cheap DWH
metadata) over the table\_stats sub-type here, which queries the asset every
run. The table\_stats sub-type is for VIEWS, or when a per-run query is
intended: a table\_stats monitor targeting a native table is withheld with a
pointer to the native tool (override with allow\_custom\_table\_stats\_on\_table).
| Flag | Type | Default | Description |
| ------------------------------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--allow-custom-table-stats-on-table` | `bool` | — | \[required] Set true to allow a table\_stats sub-type monitor on a native DWH table. By default such a monitor is withheld with a pointer to create\_table\_stats\_monitor (the native tool reads cheap DWH metadata instead of querying the table each run). Only set this after the user has chosen the per-run custom monitor anyway. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--monitors` | `string` | — | (JSON array) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools create_sql_tests`
```bash theme={null}
synq-scout tools create_sql_tests [flags]
```
CreateSqlTests creates one or more SQL tests (deterministic ids).
If unsure which check type fits the goal, call describe\_check\_types first.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--sql-tests` | `string` | — | (JSON array) |
#### `synq-scout tools create_table_stats_monitor`
```bash theme={null}
synq-scout tools create_table_stats_monitor [flags]
```
CreateTableStatsMonitor creates a table-stats monitor on one DWH TABLE and
deploys it in a single step. It reads cheap DWH metadata (row count / load
delay), so it works ONLY on DWH tables, NEVER on views: a view exposes no
such metadata, and this tool cannot supply the freshness-source column a view
would need. For a view (or materialized view / stream), use create\_monitors
with the table\_stats sub-type, a custom monitor that queries the asset
directly each run. Targeting a non-table asset is rejected with that pointer.
If unsure which check type fits the goal, call describe\_check\_types first.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--asset-path` | `string` | — | \[required] Asset to monitor (Coalesce Quality path or simple dotted path). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--metrics` | `string` | — | (JSON array) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--sensitivity` | `string` | — | \[required] Monitor-level default sensitivity, used for metrics without their own. (one of: SENSITIVITY\_UNSPECIFIED, SENSITIVITY\_PRECISE, SENSITIVITY\_BALANCED, SENSITIVITY\_RELAXED) |
| `--severity` | `string` | — | \[required] (one of: SEVERITY\_UNSPECIFIED, SEVERITY\_WARNING, SEVERITY\_ERROR, SEVERITY\_INFO) |
| `--title` | `string` | — | Optional display title. Defaults to "\ table stats" when unset. |
#### `synq-scout tools delete_data_product`
```bash theme={null}
synq-scout tools delete_data_product [flags]
```
DeleteDataProduct deletes a data product. GATED (always — deletion is
destructive): the first call returns applied=false and
requires\_user\_confirmation=true; re-call with confirmed=true after the user
approves. Soft-deletes by default; set purge to hard-delete and release the
id. Idempotent — deleting an unknown / already-deleted product succeeds.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--confirmed` | `bool` | — | Must be true to delete. When false or omitted, nothing is deleted and the call asks for confirmation. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. |
| `--id` | `string` | — | \[required] Id of the product to delete (bare UUID or 'dataproduct-\'). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--purge` | `bool` | — | \[required] Hard-delete instead of soft-delete, releasing the id for reuse. |
#### `synq-scout tools delete_deployment_rule`
```bash theme={null}
synq-scout tools delete_deployment_rule [flags]
```
DeleteDeploymentRule deletes a rule and the monitors it owns. GATED like
DeployDeploymentRule: the first call returns the monitors that would be
removed and requires\_user\_confirmation=true; re-call with confirmed=true
after the user approves.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--confirmed` | `bool` | — | \[required] Must be true to delete. When false, returns the monitors that would be removed and asks for confirmation. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to delete a rule owned by another author (the UI or a YAML config — see the response's owner field). A separate HUMAN authorization from confirmed: surface the owner to the user and get explicit approval before setting this. Never self-confirm. optional — irrelevant to the common delete of an API-owned rule, and omission reads as not-confirmed (safe). |
#### `synq-scout tools delete_domain`
```bash theme={null}
synq-scout tools delete_domain [flags]
```
DeleteDomain deletes a domain. GATED (always — deletion is destructive): the
first call returns applied=false and requires\_user\_confirmation=true, along
with the number of sub-domains that would be left behind; re-call with
confirmed=true after the user approves. Soft-deletes by default, which does
NOT delete sub-domains — they stay, parented to a deleted domain. Set purge
to hard-delete and release the id, which the backend refuses while the
domain still has sub-domains. Idempotent — deleting an unknown /
already-deleted domain succeeds.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--confirmed` | `bool` | — | Must be true to delete. When false or omitted, nothing is deleted and the call asks for confirmation. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. |
| `--id` | `string` | — | \[required] Id of the domain to delete (bare UUID or 'domain-\'). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--purge` | `bool` | — | \[required] Hard-delete instead of soft-delete, releasing the id for reuse. Refused while the domain still has sub-domains — delete or re-parent them first. |
#### `synq-scout tools delete_monitors`
```bash theme={null}
synq-scout tools delete_monitors [flags]
```
DeleteMonitors deletes monitors by id. Deleting a UI/other-config monitor is
gated on overwrite\_confirmed\_ids.
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting even though they are owned by the UI or another config. Populate only after the user approved the listed ids — not self-confirmed by the agent. |
#### `synq-scout tools delete_owner`
```bash theme={null}
synq-scout tools delete_owner [flags]
```
DeleteOwner deletes an owner and ALL of its ownerships, or — when
ownership\_id is given — just that one ownership. GATED (always — deletion is
destructive): the first call returns applied=false, the count of ownerships
that would be removed, and requires\_user\_confirmation=true; re-call with
confirmed=true after the user approves. Soft-deletes the owner by default;
set purge to hard-delete. Idempotent.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| `--confirmed` | `bool` | — | Must be true to delete. When false or omitted, nothing is deleted and the call reports what would be removed and asks for confirmation. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. |
| `--id` | `string` | — | \[required] Id of the owner (bare UUID or 'owner-\'). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--ownership-id` | `string` | — | Delete only this one ownership under the owner instead of the whole owner. The owner and its other ownerships are left intact. |
| `--purge` | `bool` | — | \[required] Hard-delete the owner instead of soft-delete (ignored when ownership\_id is set). |
#### `synq-scout tools delete_saved_view`
```bash theme={null}
synq-scout tools delete_saved_view [flags]
```
DeleteSavedView deletes a saved view. GATED (always — deletion is
destructive): the first call returns applied=false and
requires\_user\_confirmation=true; re-call with confirmed=true after the user
approves. Idempotent — deleting an unknown / already-deleted view succeeds.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--confirmed` | `bool` | — | Must be true to delete. When false or omitted, nothing is deleted and the call asks for confirmation. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. |
| `--id` | `string` | — | \[required] Id of the view to delete (UUID). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools delete_sql_tests`
```bash theme={null}
synq-scout tools delete_sql_tests [flags]
```
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting even though they are owned by the UI or another config. Populate only after the user approved the listed ids — not self-confirmed by the agent. |
#### `synq-scout tools delete_table_stats_monitor`
```bash theme={null}
synq-scout tools delete_table_stats_monitor [flags]
```
DeleteTableStatsMonitor disables table-stats monitoring for the given asset
paths by deploying an exclusion (ownership gated). Unlike deleting a per-asset
monitor, this also turns off monitors created by a broad automatic rule. To
re-enable, use create\_table\_stats\_monitor for the same asset.
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--asset-paths` | `stringArray` | — | Assets to stop monitoring (Coalesce Quality path or simple dotted path). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting even though the asset's current monitor is owned by the UI or another config (the id is reported in ownership\_conflicts). Populate only after the user approved the listed ids — not self-confirmed by the agent. |
#### `synq-scout tools deploy_deployment_rule`
```bash theme={null}
synq-scout tools deploy_deployment_rule [flags]
```
DeployDeploymentRule creates (omit id) or updates (provide id) a rule and
materializes its monitors. GATED: the first call returns applied=false,
requires\_user\_confirmation=true and changes nothing — run preview first,
surface the impact to the user, then re-call with confirmed=true after they
approve. Never self-confirm.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--confirmed` | `bool` | — | Must be true to apply. When false (or omitted), the call is a no-op that asks for confirmation (run preview first, get user approval). optional so a schema-enforcing host can omit it on a preview-first flow — omission reads as not-confirmed, the safe default. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | Omit to create (id assigned deterministically); provide to update an existing rule. When updating a rule whose query/selection changed, the existing id MUST be passed — otherwise the changed selection derives a new id and deploy mints a duplicate rule instead of updating the original. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to overwrite a rule owned by another author (the UI or a YAML config — see the response's owner field). A separate HUMAN authorization from confirmed: surface the owner to the user and get explicit approval before setting this. Never self-confirm an overwrite. optional — irrelevant to the common no-conflict deploy, and omission reads as not-confirmed (safe). |
| `--rule` | `string` | — | \[required] (JSON) |
#### `synq-scout tools describe`
Show a tool's description, scopes and input/output schemas
```bash theme={null}
synq-scout tools describe
```
#### `synq-scout tools describe_check_types`
```bash theme={null}
synq-scout tools describe_check_types [flags]
```
DescribeCheckTypes returns a static catalog of the check types this server
can create (custom monitors, SQL tests, table-stats monitors) with guidance
on which to use for which data-quality goal, down to the sub-type level. Call
it before authoring a monitor or test when unsure which check type fits.
No scope\_authorization: this is a static reference tool (no backend call,
no workspace data) so it is available to any authenticated MCP session
regardless of granted scopes. Scout's FilterToolsByScopes treats an empty
scope list as always-available.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools describe_resolver_ql`
```bash theme={null}
synq-scout tools describe_resolver_ql [flags]
```
DescribeResolverQl returns a static reference for authoring ResolverQL
selection queries: syntax, the common functions and asset-type names, worked
recipes, and the metric / sensitivity / severity enums. Call it before
authoring a rule when unsure how to express the target selection.
No scope\_authorization: this is a static reference tool (no backend call,
no workspace data) so it is available to any authenticated MCP session
regardless of granted scopes. Scout's FilterToolsByScopes treats an empty
scope list as always-available.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools execute_monitor`
```bash theme={null}
synq-scout tools execute_monitor [flags]
```
ExecuteMonitor allows reproducing behaviour of existing monitor and getting directly that monitor data from database.
Tool also allows to segment data through additional dimensions which original monitor doesn't have to find a root of the error.
Check `table_metrics.num_rows` on the underlying asset before running — large tables need
a narrow filter\_from/filter\_to window to avoid scanning the full history.
| Flag | Type | Default | Description |
| ------------------------------ | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--connection-id` | `string` | — | Integration ID of the database connection to use (must match a configured Coalesce Quality integration\_id). By default correct connection\_id will be inferred, if that doesn't work or config uses different ids, specify it. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Entity ID of the monitor which should be executed |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--segment-value` | `string` | — | For segmented monitors select specific segment to investigate |
| `--segmentation-column-names` | `stringArray` | — | Additional segmentation columns. Those columns will be used in addition to already defined segmentation of the monitor. |
| `--time-partition-column-name` | `string` | — | What column to use to filter result by time period. Might be left empty if there is no known partitioning column on the table. It is highly recommended to limit the processed data to most relevant time period to reduce processing cost and time. |
| `--time-partition-from` | `string` | — | Filter rows to have time value in 'time\_partition\_column' greater than or equal to time\_partition\_from Leave empty to use default lookback period of time |
| `--time-partition-to` | `string` | — | Filter rows to have time value in 'time\_partition\_column' greater less than 'time\_partition\_to'. Leave empty to use 'now()' |
| `--where-expressions` | `stringArray` | — | Additional conditions which will applied to the generated WHERE section of SQL query |
#### `synq-scout tools folder_of`
```bash theme={null}
synq-scout tools folder_of [flags]
```
Return the folder placement(s) each given entity lives in. Every folder
along every containing chain is returned in the `folders` table with its own
opaque id, so an ancestor is as addressable as the immediate parent — browse
or list any level without walking down from the roots.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | -------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Opaque entity ids to look up. Ids that do not exist, or live in no folder, are absent from the response. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_code`
```bash theme={null}
synq-scout tools get_code [flags]
```
This service is used by the LLM agent to fetch the latest version of source code that defines
or implements data entities, such as SQL table definitions, dbt models, SQLMesh models,
Python ETL scripts, and other data transformation code.
Identity resolution: GetCode automatically resolves sibling identities of the requested
entity (e.g. a dbt model and the DWH table it materializes share an identity group), and
returns code for any of them. There is no need to call GetCode again with a related
entity id — if the response is empty, no linked identity has code stored.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the entity to get source code for. Sibling identities (dbt model ↔ DWH table, etc.) are resolved automatically — pass any one id from the group, do not iterate across related ids. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_commit_diff`
```bash theme={null}
synq-scout tools get_commit_diff [flags]
```
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--commit-hash` | `string` | — | \[required] Required: Git commit hash (40-hex SHA, as returned in Commit.commit\_hash from list\_commits). Short/abbreviated SHAs (7+ hex chars) are also accepted and resolved to the full hash. |
| `--detail-level` | `string` | — | (one of: DETAIL\_LEVEL\_UNSPECIFIED, DETAIL\_LEVEL\_CONTENT, DETAIL\_LEVEL\_METADATA\_ONLY) |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--include-deleted-content` | `bool` | — | Whether to include content for deleted files Default: false (deleted content is usually noise) Set to true if you need to see what was removed |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-files` | `int64` | — | Maximum number of files to return Default: 10 files (ordered by: modified > added > deleted) Set to 0 to use default, or specify value between 1-100 |
| `--max-lines-per-file` | `int64` | — | Maximum lines of diff to return per file Default: 100 lines (shows \~50 first + \~50 last lines when truncated) Set to 0 to use default, or specify value between 10-10000 |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--paths` | `stringArray` | — | Optional: Filter to specific files. If empty, returns all files in commit. Subject to max\_files limit. |
#### `synq-scout tools get_common_upstream_dependencies`
```bash theme={null}
synq-scout tools get_common_upstream_dependencies [flags]
```
GetCommonUpstreamDependencies identifies shared upstream dependencies between two entities.
Uses a connected components algorithm to find entities that both inputs depend on,
including transitive relationships (e.g., if A→B, B→C, and C→D, all are grouped).
Useful for understanding data convergence points and shared data sources.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id-a` | `string` | — | \[required] First entity ID to compare. Must be a valid entity ID (e.g., table, view, dbt model, dashboard). |
| `--entity-id-b` | `string` | — | \[required] Second entity ID to compare. Must be a valid entity ID (e.g., table, view, dbt model, dashboard). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_data_product`
```bash theme={null}
synq-scout tools get_data_product [flags]
```
GetDataProduct fetches one or more data products by id with their full
detail, including the membership definition (rendered as ResolverQL).
Unknown / deleted ids are omitted from the response rather than erroring.
| Flag | Type | Default | Description |
| ---------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | Ids to fetch (bare UUID or 'dataproduct-\'). 1–200. |
| `--include-definition` | `bool` | — | Include each product's membership definition. On by default for get. |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted products. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_database_change_details`
```bash theme={null}
synq-scout tools get_database_change_details [flags]
```
Retrieves full details for one or more database changes in a single call.
Use this only when ListDatabaseChanges indicates has\_details=true (change too large for summary).
Returns the complete diffs showing what changed, concatenated in input order.
Prefer passing every change\_id you already know about in one call instead
of invoking the tool once per id.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `--change-ids` | `stringArray` | — | One or more change\_ids to fetch details for. Pass every id you want details for in a single call rather than invoking the tool once per id. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_database_coordinates_from_entity`
```bash theme={null}
synq-scout tools get_database_coordinates_from_entity [flags]
```
GetDatabaseCoordinatesFromEntity returns the physical DWH coordinates (dialect, connection, instance,
database, schema, object) for a given Coalesce Quality table entity.
| Flag | Type | Default | Description |
| ------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--table-entity-id` | `string` | — | \[required] Coalesce Quality entity ID of the table-like resource to get its DWH coordinates. |
#### `synq-scout tools get_deployment_rule`
```bash theme={null}
synq-scout tools get_deployment_rule [flags]
```
GetDeploymentRule returns one rule by id with its full settings and the
canonical resolver\_ql selection string.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_domain`
```bash theme={null}
synq-scout tools get_domain [flags]
```
GetDomain fetches one or more domains by id with their full detail,
including the membership definition (query parts rendered as ResolverQL).
Unknown / deleted ids are omitted from the response rather than erroring.
| Flag | Type | Default | Description |
| ---------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | Ids to fetch (bare UUID or 'domain-\'). 1–200. |
| `--include-definition` | `bool` | — | Include each domain's membership definition. On by default for get. |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted domains. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_downstream_dependencies`
```bash theme={null}
synq-scout tools get_downstream_dependencies [flags]
```
GetDownstreamDependencies finds all downstream dependencies for given entities.
Use this to understand the entire downstream dependency tree.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] List of entity IDs to analyze |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-distance` | `int64` | — | Controls how many levels of dependencies to traverse. Default is 1 (immediate dependencies only). Increase this value to see dependencies of dependencies. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_entity_details`
```bash theme={null}
synq-scout tools get_entity_details [flags]
```
Get details of a given entity identified by entity\_id.
Use this when you have a specific entity ID and need comprehensive information about that entity
including its properties, metadata, and current state.
For DWH table/view entities the response includes `table_metrics` (latest row count and
freshness) — check it before issuing unbounded queries against the underlying table.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_entity_from_database_coordinates`
```bash theme={null}
synq-scout tools get_entity_from_database_coordinates [flags]
```
GetEntityFromDatabaseCoordinates maps a SQL table reference to Coalesce Quality entity IDs for physical tables in the data warehouse.
The input `sql_fqn` may be fully qualified (e.g. "db.schema.table"), partially qualified ("schema.table"), or
unqualified ("table"). Matching is hierarchical: more specific references narrow the search.
Partial references may match multiple entities (for example, the same table name across different schemas or instances).
Returns all matches including their actual database FQN, dialect, and connection.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--sql-fqn` | `string` | — | \[required] Fully qualified SQL table name to resolve, e.g. "db.schema.table", "schema.table", or bare table name. |
#### `synq-scout tools get_entity_impact`
```bash theme={null}
synq-scout tools get_entity_impact [flags]
```
Get impact analysis showing all entities and systems affected if there was an issue on the entity.
Use this to understand the blast radius and downstream effects of problems with a specific entity.
Essential for incident response and change impact assessment.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the issue to get impact analysis for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_entity_metrics`
```bash theme={null}
synq-scout tools get_entity_metrics [flags]
```
Returns raw metric timeseries (e.g., row counts, freshness timestamps) for an entity.
Identity-aware: resolves logical assets (e.g., dbt models) to their underlying physical tables.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Entity ID of the table, view, or dbt model. |
| `--from` | `string` | — | Start of time range. Defaults to 3 days before 'to'. Max lookback: 30 days. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-points` | `int64` | — | Maximum number of data points to return. When the window contains more, the most recent 'max\_points' are returned and 'tool\_usage\_guidance' explains how to see the older ones. Defaults to 500. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--to` | `string` | — | End of time range. Defaults to now. |
#### `synq-scout tools get_immediate_downstream_dependencies`
```bash theme={null}
synq-scout tools get_immediate_downstream_dependencies [flags]
```
GetImmediateDownstreamDependencies finds only the direct downstream dependencies.
Use this for quick analysis of immediate data sources without deep traversal.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] List of entity IDs to analyze |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_immediate_upstream_dependencies`
```bash theme={null}
synq-scout tools get_immediate_upstream_dependencies [flags]
```
GetImmediateUpstreamDependencies retrieves only direct (one-hop) upstream dependencies.
This is faster than GetUpstreamDependencies and useful for quick analysis of immediate data sources.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] Entity IDs to analyze immediate upstream dependencies for. Each entity ID uniquely identifies a data asset (e.g., table, view, dbt model, dashboard). At least one entity ID is required. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_incident_details`
```bash theme={null}
synq-scout tools get_incident_details [flags]
```
Retrieve detailed information about a specific incident by its ID,
including attached issues, state, and comment timeline. Use this when
you already have an incident ID (from create\_incident, a URL, or a
list\_open\_incidents result) instead of filtering list\_open\_incidents
client-side.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--incident-id` | `string` | — | \[required] Unique identifier of the incident to retrieve |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_issue`
```bash theme={null}
synq-scout tools get_issue [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-id` | `string` | — | \[required] Unique identifier of the issue to retrieve |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_issue_comments`
```bash theme={null}
synq-scout tools get_issue_comments [flags]
```
| Flag | Type | Default | Description |
| ------------------ | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-id` | `string` | — | \[required] Unique identifier of the issue to retrieve |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 20, max: 100) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1) |
#### `synq-scout tools get_issue_details`
```bash theme={null}
synq-scout tools get_issue_details [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-id` | `string` | — | \[required] Unique identifier of the issue to retrieve |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_issue_impact`
```bash theme={null}
synq-scout tools get_issue_impact [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-id` | `string` | — | \[required] Unique identifier of the issue to get impact analysis for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_latest_executions`
```bash theme={null}
synq-scout tools get_latest_executions [flags]
```
Get the latest execution for each specified entity.
IMPORTANT: Only returns executions where the entity appears in execution.entity\_ids (what executed).
This means it returns executions OF the entity (e.g., model runs, monitor runs, task runs),
NOT executions that merely reference the entity (e.g., tables don't execute on their own).
Use this to quickly check the current state and most recent execution status of executable entities.
| Flag | Type | Default | Description |
| ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Entity identifiers to get latest executions for (required) Only returns executions where these entities appear in execution.entity\_ids (what executed). Examples that WILL return results: monitors, dbt models, airflow tasks, tests Examples that WON'T return results: tables (they don't execute, they are created/updated by models) |
| `--execution-types` | `stringArray` | — | Filter by execution types (if empty, returns latest regardless of type) Common values include: DBT\_INVOCATION, DBT\_NODE\_INVOCATION, SNOWFLAKE\_QUERY\_LOG, BIGQUERY\_QUERY\_JOB, CLICKHOUSE\_QUERY\_LOG, AIRFLOW\_DAG, AIRFLOW\_TASK, ANOMALY\_MONITOR\_RUN, ANOMALY\_MONITOR\_SEGMENT\_RUN, SQL\_TEST\_RUN, etc. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--statuses` | `stringArray` | — | Filter by execution status (if empty, returns latest regardless of status) Valid values: "ok", "warn", "error", "critical", "unspecified" Note: "unspecified" indicates debug/info status (something happened but doesn't affect entity state) |
#### `synq-scout tools get_lineage`
```bash theme={null}
synq-scout tools get_lineage [flags]
```
GetLineage retrieves all dependencies for specified entities.
This helps understand what feeds into (upstream) or depends on (downstream) the given entities.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--direction` | `string` | — | \[required] Specifies which dependencies to return: - "upstream": only show what feeds into these entities - "downstream": only show what depends on these entities - leave empty to show both directions |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] List of entity IDs to analyze |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-depth` | `int64` | — | \[required] Controls how many levels of dependencies to traverse. Default is 1 (immediate dependencies only). Increase this value to see dependencies of dependencies. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_monitor`
```bash theme={null}
synq-scout tools get_monitor [flags]
```
Retrieve the full configuration of a single monitor by its monitor\_entity\_id.
Returns the monitor's complete settings: type, metrics, sensitivity, severity, schedule,
segmentation, filters, and current state. Use this to inspect or check how one specific
monitor is configured — e.g. before editing it, or to explain why it did or did not fire.
Get the monitor\_entity\_id from list\_checks or from an issue/monitor context.
| Flag | Type | Default | Description |
| --------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--monitor-entity-id` | `string` | — | \[required] Unique identifier of the monitor entity |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_monitor_predictions`
```bash theme={null}
synq-scout tools get_monitor_predictions [flags]
```
Returns recent model predictions for a monitor, showing expected vs actual values and confidence bands.
Use this to understand whether the anomaly detection model is well-calibrated or miscalibrated
(e.g., predicting impossible negative values for row counts).
The response includes the model's predicted (expected) values, actual observed values, confidence bands,
and anomaly patterns for each time bucket.
| Flag | Type | Default | Description |
| --------------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--from` | `string` | — | Start of time range. Defaults to 3 days before 'to'. Max lookback: 30 days. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-points` | `int64` | — | Maximum number of predictions to return. When the window contains more, the most recent 'max\_points' are returned and 'tool\_usage\_guidance' explains how to see the older ones. Defaults to 500. |
| `--monitor-entity-id` | `string` | — | \[required] Entity ID of the monitor (e.g., from the issue trigger's monitor\_entity\_id). |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--segment` | `string` | — | Segment filter. If empty, all segments are returned. |
| `--to` | `string` | — | End of time range. Defaults to now. |
#### `synq-scout tools get_orchestration`
```bash theme={null}
synq-scout tools get_orchestration [flags]
```
Get orchestration relationships for multiple entities.
For each entity, returns both upstream entities (what orchestrates it) and
downstream entities (what it orchestrates).
The tool automatically selects the most relevant entity ID from each orchestration group
using entity type priority (models > tables > tasks > checks > jobs).
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Entity IDs to query for orchestration relationships |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_owner`
```bash theme={null}
synq-scout tools get_owner [flags]
```
GetOwner fetches one or more owners by id with their full detail: contacts
and, by default, their ownerships (assigned assets + alert config). Unknown /
deleted ids are omitted rather than erroring.
| Flag | Type | Default | Description |
| ---------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | Owner ids to fetch (bare UUID or 'owner-\'). 1–200. |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted owners. |
| `--include-ownerships` | `bool` | — | Include each owner's ownerships. On by default for get. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_saved_view`
```bash theme={null}
synq-scout tools get_saved_view [flags]
```
GetSavedView fetches one or more saved views by id with their full detail:
the selection (rendered as ResolverQL), display config, sharing, grants, the
caller's permissions, and pin state. Ids the caller cannot see are omitted.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | View ids to fetch (UUIDs). 1–200. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_schema`
```bash theme={null}
synq-scout tools get_schema [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the entity to get the schema for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_upstream_dependencies`
```bash theme={null}
synq-scout tools get_upstream_dependencies [flags]
```
GetUpstreamDependencies traverses the dependency graph to find all upstream dependencies
for the specified entities up to a configurable depth.
Use this to understand the complete upstream dependency tree and data flow.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] Entity IDs to analyze upstream dependencies for. Each entity ID uniquely identifies a data asset (e.g., table, view, dbt model, dashboard). At least one entity ID is required. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--max-distance` | `int64` | — | Maximum depth of dependency traversal (number of hops from the starting entities). - 1: Only immediate (direct) dependencies - 2: Direct dependencies and their dependencies - 3+: Continues deeper into the dependency graph Default: 1 (if not specified) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools get_upstream_sources`
```bash theme={null}
synq-scout tools get_upstream_sources [flags]
```
GetUpstreamSources traces lineage to the root of the dependency graph to find original data sources.
Identifies dbt sources, SQLMesh external models, or the furthest reachable upstream entities.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | \[required] Entity IDs to trace back to their original data sources. Each entity ID uniquely identifies a data asset (e.g., table, view, dbt model, dashboard). At least one entity ID is required. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools iam`
```bash theme={null}
synq-scout tools iam [flags]
```
Iam returns information about the authenticated caller: workspace,
granted scopes, token subject, and (when present) the Coalesce Quality
user and integration associated with the token.
Use this tool when:
```bash theme={null}
- the user asks "who am I?", "what workspace am I in?", or "what can I do?"
- you need to report identity or granted scopes back to the user for transparency
- you are troubleshooting an unexpected authorization error and want to
inspect the exact scope list the token carries
```
Exposed on any common read scope so it's available in every MCP session.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list`
List available MCP tools
```bash theme={null}
synq-scout tools list
```
#### `synq-scout tools list_annotations`
```bash theme={null}
synq-scout tools list_annotations [flags]
```
List all available annotations with their usage counts across entities.
This provides insight into the annotation ecosystem, showing which annotations
are commonly used and their frequency distribution across the entity catalog.
| Flag | Type | Default | Description |
| ------------------ | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 10, max: 100) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1) |
#### `synq-scout tools list_checks`
```bash theme={null}
synq-scout tools list_checks [flags]
```
ListChecks retrieves all data quality checks configured for a specific entity.
This includes both checks directly defined on the entity and those inherited from
upstream dependencies. It also provides information about column usage patterns.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the entity to get checks for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_commits`
```bash theme={null}
synq-scout tools list_commits [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--before-date` | `string` | — | Return commits that occurred before this timestamp. Leave empty to get commits from now |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the entity to get commits for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--lookback-days` | `int64` | — | Number of days to check in the past. Defaults to 7. Maximum 90 days. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_data_product_members`
```bash theme={null}
synq-scout tools list_data_product_members [flags]
```
ListDataProductMembers resolves a data product's membership definition and
returns the opaque entity ids of the assets that currently belong to it,
paginated.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] Id of the product whose members to list (bare UUID or 'dataproduct-\'). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max members to return in one page. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. |
#### `synq-scout tools list_data_products`
```bash theme={null}
synq-scout tools list_data_products [flags]
```
ListDataProducts lists the data products in the workspace, paginated.
Narrow with folder and priorities. Definitions are omitted by default (set
include\_definition to include the membership query); use get\_data\_product
for a single product's full detail.
| Flag | Type | Default | Description |
| ---------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--folder` | `string` | — | Restrict to a single folder. |
| `--include-definition` | `bool` | — | \[required] Include each product's membership definition in the rows. Off by default to keep the list compact — definitions can be large. Use get\_data\_product for a single product's definition instead of listing them all. |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted products. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max products to return in one page. Defaults to a bounded page size; the backend never returns every product at once. Use next\_page\_token to continue, not row count. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. Omit for the first page. |
| `--priorities` | `stringArray` | — | Restrict to these priorities. Empty returns all priorities. |
#### `synq-scout tools list_database_changes`
```bash theme={null}
synq-scout tools list_database_changes [flags]
```
Retrieves the history of database schema and SQL definition changes for a specific entity.
Returns changes detected by Coalesce Quality's schema monitoring, ordered from most recent to oldest.
Example use cases:
* "Show me schema changes to the users table in the last week"
* "What SQL definition changes happened to the customer\_summary view?"
* "When was the last time a column was added to this table?"
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--before-date` | `string` | — | Return changes before this timestamp. Leave empty for last 7 days. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the entity to get changes for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--lookback-days` | `int64` | — | Number of days to check in the past. Defaults to 7. Maximum 7 days. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_deployment_rules`
```bash theme={null}
synq-scout tools list_deployment_rules [flags]
```
ListDeploymentRules lists query-based deployment rules, optionally filtered
by ids or config. Use it to find the rule id to inspect, preview, or delete.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--config-id` | `string` | — | Filter to a config namespace (optional). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max rules to return in one page. Defaults to a bounded page size when unset; the backend never returns every rule at once. The backend filters to the rule types this tool manages (query, exclusive-query, product) before paging, so a page holds up to 'limit' of those — use next\_page\_token to continue, not row count. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. Omit for the first page. |
| `--rule-ids` | `stringArray` | — | Filter to specific rule ids (optional). |
#### `synq-scout tools list_domain_members`
```bash theme={null}
synq-scout tools list_domain_members [flags]
```
ListDomainMembers resolves a domain's membership definition and returns the
opaque entity ids of the assets that currently belong to it, paginated. The
resolution is recursive: it includes everything contributed by the data
products and domains the definition references, and by the domain's own
sub-domains.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] Id of the domain whose members to list (bare UUID or 'domain-\'). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max members to return in one page. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. |
#### `synq-scout tools list_domains`
```bash theme={null}
synq-scout tools list_domains [flags]
```
ListDomains lists the domains in the workspace, paginated. Use parent\_id to
walk the hierarchy. Membership definitions are never included — they can be
large; use get\_domain for a single domain's definition.
| Flag | Type | Default | Description |
| ------------------- | -------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted domains. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max domains to return in one page. Defaults to a bounded page size; the backend never returns every domain at once. Use next\_page\_token to continue, not row count. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. Omit for the first page. |
| `--parent-id` | `string` | — | Walk the hierarchy: omit to return every domain at any level, pass a domain id to return only that domain's direct children, or pass an empty string to return only top-level domains. |
#### `synq-scout tools list_executions`
```bash theme={null}
synq-scout tools list_executions [flags]
```
List executions for specific entities with optional filtering by time range and status.
Returns execution history in reverse chronological order (newest first).
Use this to investigate when specific entities were executed, their status, and any error messages.
| Flag | Type | Default | Description |
| ---------------------------- | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Entity identifiers to get executions for (required) |
| `--execution-started-after` | `string` | — | Return executions that started after this timestamp. If not provided, derived from lookback\_days (see below), and if that is also unset defaults to execution\_started\_before minus 3 days. |
| `--execution-started-before` | `string` | — | Return executions that started before this timestamp If not provided, defaults to now() |
| `--execution-types` | `stringArray` | — | Filter by specific execution types. Common values include: DBT\_INVOCATION, DBT\_NODE\_INVOCATION, SNOWFLAKE\_QUERY\_LOG, BIGQUERY\_QUERY\_JOB, CLICKHOUSE\_QUERY\_LOG, AIRFLOW\_DAG, AIRFLOW\_TASK, ANOMALY\_MONITOR\_RUN, ANOMALY\_MONITOR\_SEGMENT\_RUN, SQL\_TEST\_RUN, etc. Leave empty to include all execution types. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Maximum number of executions to return (default: 50, max: 100) |
| `--lookback-days` | `int64` | — | Convenience time window: return executions from the last N days. Prefer this over execution\_started\_after for simple "recent" lookups — execution\_started\_after is computed as (execution\_started\_before or now()) minus lookback\_days days. Ignored when execution\_started\_after is set explicitly. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--statuses` | `stringArray` | — | Filter by execution status. Valid values: "ok", "warn", "error", "critical", "unspecified" Note: "unspecified" indicates debug/info status (something happened but doesn't affect entity state) Leave empty to include all statuses. |
#### `synq-scout tools list_folder_members`
```bash theme={null}
synq-scout tools list_folder_members [flags]
```
List the entity ids contained in a folder, paginated. Direct members only by
default; set deep=true to include members of all nested sub-folders. Narrow
with types. Prefer a larger limit over many small pages — paging deep through
a large folder repeats work server-side.
| Flag | Type | Default | Description |
| -------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--deep` | `bool` | — | \[required] Include members of all nested sub-folders. Default false = direct members only. Note the deep set also contains the intermediate container levels themselves, not only leaf entities, and total\_count counts both. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--folder-entity-id` | `string` | — | \[required] Opaque id of the folder whose members to list (a folder\_entity\_id from any FolderNode). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max entity ids per page. Defaults to a bounded page size when unset. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. Omit for the first page. |
| `--types` | `stringArray` | — | Optional entity-type filter (e.g. \["table", "view"]). Empty returns all types. Call describe\_resolver\_ql for the common type names. |
#### `synq-scout tools list_history`
```bash theme={null}
synq-scout tools list_history [flags]
```
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-id` | `string` | — | \[required] Unique identifier of the issue to find historical data for |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_monitors`
```bash theme={null}
synq-scout tools list_monitors [flags]
```
ListMonitors lists custom monitors, optionally filtered by asset, config,
ids, or a name substring. Use it to find the monitor id to update or delete.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--asset-path` | `string` | — | Filter to monitors on this asset (Coalesce Quality path or simple dotted path). |
| `--config-id` | `string` | — | Filter to monitors in this config/namespace. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | Filter to specific monitor ids. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--name-search` | `string` | — | Case-insensitive substring match on monitor name. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_open_incidents`
```bash theme={null}
synq-scout tools list_open_incidents [flags]
```
| Flag | Type | Default | Description |
| ------------------ | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Limit incidents to the specific entities. Leave empty to get all open incidents. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 20, max: 100) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1) |
#### `synq-scout tools list_open_issues`
```bash theme={null}
synq-scout tools list_open_issues [flags]
```
| Flag | Type | Default | Description |
| ------------------ | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Limit issues to the specific entities. Leave empty to get all open issues. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 20, max: 100) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1) |
#### `synq-scout tools list_owners`
```bash theme={null}
synq-scout tools list_owners [flags]
```
ListOwners lists the owners in the workspace, paginated. Each row carries the
contact count; set include\_ownership\_counts to also resolve each owner's
ownership count (an extra query per owner — off by default).
| Flag | Type | Default | Description |
| ---------------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted owners. |
| `--include-ownership-counts` | `bool` | — | \[required] Resolve each owner's ownership count (an extra query per owner). Off by default to keep the list cheap. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max owners to return in one page. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. |
#### `synq-scout tools list_ownerships`
```bash theme={null}
synq-scout tools list_ownerships [flags]
```
ListOwnerships lists ownerships — either all ownerships of one owner
(owner\_id) or a specific set across owners (ownership\_ids). Each row shows
the asset selection and the alert configuration.
| Flag | Type | Default | Description |
| ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--include-deleted` | `bool` | — | \[required] Include soft-deleted ownerships. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max ownerships to return in one page (owner\_id mode). |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--owner-id` | `string` | — | List all ownerships of this owner (bare UUID or 'owner-\'). Provide either owner\_id or ownership\_ids. |
| `--ownership-ids` | `stringArray` | — | Fetch a specific set of ownerships by id (across owners). Takes precedence over owner\_id when set. |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token (owner\_id mode). |
#### `synq-scout tools list_saved_views`
```bash theme={null}
synq-scout tools list_saved_views [flags]
```
ListSavedViews lists the saved views the calling user can see. By default
every visible view (their own, shared-with-workspace, granted-to-them);
narrow with relationships, context and only\_pinned.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--context` | `string` | — | Restrict to a single surface (catalog / checks / issues). Omit for all. (one of: SAVED\_VIEW\_CONTEXT\_UNSPECIFIED, SAVED\_VIEW\_CONTEXT\_CHECKS, SAVED\_VIEW\_CONTEXT\_ISSUES) |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max views to return in one page. |
| `--only-pinned` | `bool` | — | Restrict to views the caller has pinned. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. |
| `--relationships` | `stringArray` | — | Relationship buckets to include. Empty returns every view the caller can see. |
#### `synq-scout tools list_sql_tests`
```bash theme={null}
synq-scout tools list_sql_tests [flags]
```
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--asset-path` | `string` | — | Filter to SQL tests on this asset (Coalesce Quality path or simple dotted path). |
| `--config-id` | `string` | — | |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--name-search` | `string` | — | |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_table_stats_monitors`
```bash theme={null}
synq-scout tools list_table_stats_monitors [flags]
```
ListTableStatsMonitors lists table-stats monitors (static deployment rules),
optionally filtered by asset or ids.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `--asset-path` | `string` | — | Filter to table-stats monitors on this asset (Coalesce Quality path or simple dotted path). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--ids` | `stringArray` | — | |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools list_users`
```bash theme={null}
synq-scout tools list_users [flags]
```
List users in the current workspace. Supports a substring filter on name
or email plus simple page-based pagination. Use this before calling
`update_incident` with `owner_email` so the picked email matches an
existing workspace user.
| Flag | Type | Default | Description |
| ------------------ | -------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 50, max: 200). |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1). |
| `--query` | `string` | — | Case-insensitive substring matched against email, first name, last name, and the combined "first last" display name. Leave empty to return every user in the workspace. |
#### `synq-scout tools preview_deployment_rule`
```bash theme={null}
synq-scout tools preview_deployment_rule [flags]
```
PreviewDeploymentRule resolves the rule's query and returns the monitors that
would be created, deleted, or kept if it were deployed now, plus assets
skipped (e.g. no freshness column). Side-effect-free; nothing is written.
Doubles as validation: a malformed resolver\_ql returns an invalid-argument
error with the parse message — fix it and preview again.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | Provide the existing rule id to preview an UPDATE: the overview then reflects the true delta (settings\_changes, kept monitors) against the live rule. Omit to preview a CREATE (overview computed as brand-new). For an update that changes the query/selection, the same id must be passed to deploy\_deployment\_rule — otherwise deploy mints a new rule. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--rule` | `string` | — | \[required] (JSON) |
#### `synq-scout tools profile_columns`
```bash theme={null}
synq-scout tools profile_columns [flags]
```
ProfileColumns computes statistical information about column values. Only specific columns can be profiled.
Columns which do not support profiling are ignored. Profiles are generated for String, Numeric and Time columns of different native types.
If you decide to profile data, fetch the data for limited time period to avoid excessive data queries.
Check `table_metrics.num_rows` from GetEntityDetails first — for billion-row tables pass a
narrow time window (filter\_from/filter\_to) rather than scanning the full history.
| Flag | Type | Default | Description |
| ------------------------------ | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--connection-id` | `string` | — | Integration ID of the database connection to use (must match a configured Coalesce Quality integration\_id). By default correct connection\_id will be inferred, if that doesn't work or config uses different ids, specify it. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the table-like entity |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--profile-column-names` | `stringArray` | — | \[required] List of columns to be profiled. Must exist in table schema. Max 5 columns per operation. |
| `--segmentation-column-names` | `stringArray` | — | Additional columns used for segmentation of data |
| `--time-partition-column-name` | `string` | — | What column to use to filter result by time period. Might be left empty if there is no known partitioning column on the table. It is highly recommended to limit the processed data to most relevant time period to reduce processing cost and time. |
| `--time-partition-from` | `string` | — | Filter rows to have time value in 'time\_partition\_column' greater than or equal to time\_partition\_from Leave empty to use default lookback period of time. |
| `--time-partition-to` | `string` | — | Filter rows to have time value in 'time\_partition\_column' greater less than 'time\_partition\_to'. Leave empty to use 'now()'. |
| `--where-expressions` | `stringArray` | — | Additional conditions which will applied to the generated WHERE section of SQL query |
#### `synq-scout tools resolve_query`
```bash theme={null}
synq-scout tools resolve_query [flags]
```
Compile and evaluate a ResolverQL expression, returning the matched entity
ids (paginated). A syntactically invalid or uncompilable expression comes
back as an invalid-argument error with the parse message — fix it and retry.
Call describe\_resolver\_ql for the grammar.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit` | `int64` | — | Max entity ids per page. Defaults to a bounded page size when unset. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page-token` | `string` | — | Opaque cursor from a previous response's next\_page\_token. Omit for the first page. |
| `--resolver-ql` | `string` | — | \[required] ResolverQL selection to evaluate, e.g. 'with\_type("table", filter=with\_platform("snowflake"))'. Call describe\_resolver\_ql for the grammar. |
#### `synq-scout tools sample_column_values`
```bash theme={null}
synq-scout tools sample_column_values [flags]
```
SampleColumnValues returns frequency of values for a specific column.
If you decide to sample data, fetch the data for limited time period to avoid excessive data queries.
Check `table_metrics.num_rows` from GetEntityDetails first — for billion-row tables pass a
narrow time window (filter\_from/filter\_to) rather than scanning the full history.
| Flag | Type | Default | Description |
| ------------------------------ | ------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--column-names` | `stringArray` | — | \[required] List of column names to fetch data for. Must exist in table schema. |
| `--connection-id` | `string` | — | Integration ID of the database connection to use (must match a configured Coalesce Quality integration\_id). By default correct connection\_id will be inferred, if that doesn't work or config uses different ids, specify it. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-id` | `string` | — | \[required] Unique identifier of the table-like entity |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--time-partition-column-name` | `string` | — | What column to use to filter result by time period. Might be left empty if there is no known partitioning column on the table. It is highly recommended to limit the processed data to most relevant time period to reduce processing cost and time. |
| `--time-partition-from` | `string` | — | Filter rows >= time\_partition\_from. Leave empty for default lookback |
| `--time-partition-to` | `string` | — | Filter rows \< time\_partition\_to. Leave empty for now() |
| `--where-expressions` | `stringArray` | — | Additional conditions which will applied to the generated WHERE section of SQL query |
#### `synq-scout tools sample_entities`
```bash theme={null}
synq-scout tools sample_entities [flags]
```
Get entity count sampling by type for a search query.
Use this to get rough estimates and understand the distribution of entity types
that match a search query. Ideal for initial exploration when you want to understand
"what kinds of things exist" before drilling down with SearchEntities.
Much more efficient than SearchEntities when you only need counts and type distribution.
| Flag | Type | Default | Description |
| ------------------ | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-to-types` | `stringArray` | — | Optional limit to specific entity types |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--query` | `string` | — | \[required] Search query |
#### `synq-scout tools save_data_product`
```bash theme={null}
synq-scout tools save_data_product [flags]
```
SaveDataProduct creates (omit id, or supply a fresh UUID) or updates
(supply an existing id) a data product and, in the same call, replaces its
membership definition when one is provided. Mutable fields are optional on
update: a set field is written, an omitted field is left unchanged (pass an
empty folder to clear it). GATED: the first call returns applied=false,
requires\_user\_confirmation=true and changes nothing — surface the impact to
the user, then re-call with confirmed=true. A product managed by an external
source (e.g. Atlan) is read-only in the app; overwriting it additionally
requires overwrite\_confirmed=true. Never self-confirm.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--confirmed` | `bool` | — | Must be true to apply. When false or omitted, the call changes nothing and asks for confirmation (the safe default). |
| `--definition` | `string` | — | Membership definition (full replace). Author query parts as ResolverQL (see describe\_resolver\_ql) or pin assets by entity id. Omit to keep the existing definition; pass an empty definition to clear it. A data product may not reference another data product or domain. (JSON) |
| `--description` | `string` | — | Description. Omit to keep the existing description. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. When set, the write fails with a conflict if the product changed since — re-read and retry. |
| `--folder` | `string` | — | Folder. Omit to keep the existing folder; pass an empty string to clear it. |
| `--id` | `string` | — | Opaque id of the product (bare UUID or 'dataproduct-\'). Omit to create a new product (a UUID is minted and returned). Supply an existing id to update. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to overwrite a product managed by an external source (e.g. Atlan), which is otherwise read-only. A separate HUMAN authorization from confirmed — surface the source to the user and get explicit approval. Never self-confirm. |
| `--priority` | `string` | — | Priority. Omit to keep the existing priority. (one of: PRIORITY\_UNSPECIFIED, PRIORITY\_P3, PRIORITY\_P2, PRIORITY\_P1) |
| `--title` | `string` | — | Title. Required when creating; omit to keep the existing title on update. |
#### `synq-scout tools save_domain`
```bash theme={null}
synq-scout tools save_domain [flags]
```
SaveDomain creates (omit id, or supply a fresh UUID) or updates (supply an
existing id) a domain and, in the same call, replaces its membership
definition when one is provided. Mutable fields are optional on update: a
set field is written, an omitted field is left unchanged (pass an empty
parent\_id to detach the domain and make it top-level). GATED: the first call
returns applied=false, requires\_user\_confirmation=true and changes nothing —
surface the impact to the user, then re-call with confirmed=true. A domain
managed by an external source (e.g. Atlan) is read-only in the app;
overwriting it additionally requires overwrite\_confirmed=true. Never
self-confirm. A re-parent or definition reference that would close a loop in
the domain / data-product reference graph is rejected.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--confirmed` | `bool` | — | Must be true to apply. When false or omitted, the call changes nothing and asks for confirmation (the safe default). |
| `--definition` | `string` | — | Membership definition (full replace). Parts are OR'd: pin an asset by its entity\_id, include a whole data product by dataproduct\_id, include a whole other domain by domain\_id, or select assets with a query — author queries as ResolverQL (see describe\_resolver\_ql). Omit to keep the existing definition; pass an empty definition to clear it. A reference that would close a loop is rejected. (JSON) |
| `--description` | `string` | — | Description. Omit to keep the existing description. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. When set, the write fails with a conflict if the domain changed since — re-read and retry. |
| `--id` | `string` | — | Opaque id of the domain (bare UUID or 'domain-\'). Omit to create a new domain (a UUID is minted and returned). Supply an existing id to update. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--name` | `string` | — | Name. Required when creating; omit to keep the existing name on update. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to overwrite a domain managed by an external source (e.g. Atlan), which is otherwise read-only. A separate HUMAN authorization from confirmed — surface the source to the user and get explicit approval. Never self-confirm. |
| `--parent-id` | `string` | — | Parent domain, making this a sub-domain (bare UUID or 'domain-\'). Omit to keep the current parent; pass an empty string to detach the domain and make it top-level. The parent must already exist, and the write is rejected if it would make the hierarchy loop. |
#### `synq-scout tools save_owner`
```bash theme={null}
synq-scout tools save_owner [flags]
```
SaveOwner creates (omit id) or updates (supply an existing id) an owner and,
in the same call, upserts the ownerships listed under it (owner + its
ownerships fanned out to the backend). Owner mutable fields are optional on
update: a set field is written, an omitted field left unchanged; a present
(possibly empty) contacts list replaces the contacts. Each ownership is
upserted by its id (omit to create). Assigning a data product already owned
by another ownership MOVES it. GATED: the first call returns applied=false,
requires\_user\_confirmation=true and changes nothing — surface the impact,
then re-call with confirmed=true. An owner managed by an external source
(e.g. Atlan) is read-only; overwriting it additionally requires
overwrite\_confirmed=true. Never self-confirm.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--confirmed` | `bool` | — | Must be true to apply. When false or omitted, nothing is written and the call asks for confirmation. |
| `--contacts` | `string` | — | Notification channels (full replace). Omit to leave contacts unchanged; pass a present (possibly empty) list to replace them. (JSON) |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard for the owner from a prior read. |
| `--id` | `string` | — | Opaque id of the owner (bare UUID or 'owner-\'). Omit to create a new owner (a UUID is minted and returned). |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to overwrite an owner managed by an external source (e.g. Atlan). A separate HUMAN authorization from confirmed. Never self-confirm. |
| `--ownerships` | `string` | — | Ownerships to upsert under this owner. Each is created (omit its id) or updated (supply its id). Omitting this list leaves the owner's existing ownerships unchanged; it does NOT delete them (use delete\_owner with an ownership\_id to remove one). (JSON array) |
| `--title` | `string` | — | Owner name. Required when creating; omit to keep the existing name on update. |
#### `synq-scout tools save_saved_view`
```bash theme={null}
synq-scout tools save_saved_view [flags]
```
SaveSavedView creates (omit id) or updates (supply an existing id) a saved
view. Mutable fields are optional on update: a set field is written, an
omitted field left unchanged. GATED: the first call returns applied=false,
requires\_user\_confirmation=true and changes nothing — surface the impact,
then re-call with confirmed=true. Editing a view the caller does not own, or
changing its visibility / grants (who else can see it), additionally requires
overwrite\_confirmed=true. Never self-confirm.
| Flag | Type | Default | Description |
| ----------------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--config` | `string` | — | Display configuration. Omit to keep the existing config. (JSON) |
| `--confirmed` | `bool` | — | Must be true to apply. When false or omitted, nothing is written and the call asks for confirmation. |
| `--context` | `string` | — | Surface the view applies to. Omit to keep the existing context (defaults to catalog on create). (one of: SAVED\_VIEW\_CONTEXT\_UNSPECIFIED, SAVED\_VIEW\_CONTEXT\_CHECKS, SAVED\_VIEW\_CONTEXT\_ISSUES) |
| `--description` | `string` | — | Description. Omit to keep the existing description. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--etag` | `string` | — | Optional optimistic-concurrency guard from a prior read. |
| `--grants` | `string` | — | Access grants (full replace; an empty list clears all grants). Omit to leave grants unchanged. Changing this needs overwrite\_confirmed. (JSON) |
| `--id` | `string` | — | Opaque UUID of the view. Omit to create a new view (a UUID is minted and returned); supply an existing id to update. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed` | `bool` | — | Must be true to edit a view the caller does not own, or to change visibility / grants. A separate HUMAN authorization from confirmed. Never self-confirm. |
| `--resolver-ql` | `string` | — | The selection as ResolverQL (see describe\_resolver\_ql). Required when creating; omit to keep the existing selection on update. |
| `--title` | `string` | — | Title. Required when creating; omit to keep the existing title on update. |
| `--visibility` | `string` | — | Sharing state. Omit to keep the existing visibility. Changing this needs overwrite\_confirmed (it affects who else can see the view). (one of: SAVED\_VIEW\_VISIBILITY\_UNSPECIFIED, SAVED\_VIEW\_VISIBILITY\_SHARED, SAVED\_VIEW\_VISIBILITY\_GRANTED) |
#### `synq-scout tools search_entities`
```bash theme={null}
synq-scout tools search_entities [flags]
```
Search for entities by name, description, etc.
Use this when you need to find specific entities and want the full entity details in results.
Returns actual Entity objects with complete information. Best for detailed exploration
and when you need to work with the found entities directly.
Each hit includes `table_metrics` (row count, freshness) when available — use it to
decide whether candidate tables are safe to query without partition filters.
| Flag | Type | Default | Description |
| ------------------ | ------------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--limit-per-page` | `int64` | — | Results per page (default: 20, max: 100) |
| `--limit-to-types` | `stringArray` | — | Optional limit to specific entity types |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--page` | `int64` | — | Page number for pagination (1-based, default: 1) |
| `--query` | `string` | — | \[required] Search query |
#### `synq-scout tools set_issue_status`
```bash theme={null}
synq-scout tools set_issue_status [flags]
```
Set the status of a single issue. Use this once the user has decided how to
classify an issue (e.g., expected behaviour, fixed upstream, no action
needed). An optional note is posted as a comment alongside the status
change so the audit trail captures why the decision was made.
| Flag | Type | Default | Description |
| ----------------- | ------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--issue-ids` | `stringArray` | — | Issue IDs whose status should be updated. All listed issues are updated to the same target status. At least one ID must be provided. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--note` | `string` | — | Optional Markdown note explaining the status change. When provided, it is posted as a comment on every listed issue using the same acting user so reviewers can see why the status was changed. Prefer to include a short reason for statuses like 'expected', 'no\_action\_needed' or 'fixed'. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--status` | `string` | — | New status to apply to the issues. Omit the field to clear the existing status and return the issues to the default/untriaged state. (one of: investigating, expected, fixed, no\_action\_needed) |
#### `synq-scout tools set_saved_view_pin`
```bash theme={null}
synq-scout tools set_saved_view_pin [flags]
```
SetSavedViewPin pins or unpins a saved view to the calling user's main
screen. UNGATED: pinning is a per-user preference with zero blast radius — it
applies only to the caller and does not modify the view — so any user who can
see the view may pin it, and no confirmation is required.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] Id of the view to pin / unpin for the calling user. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--pinned` | `bool` | — | \[required] Desired pin state: true to pin, false to unpin. |
#### `synq-scout tools submit_feature_request`
```bash theme={null}
synq-scout tools submit_feature_request [flags]
```
SubmitFeatureRequest submits a feature request to the Coalesce Quality product team.
IMPORTANT: This is a last-resort tool. Only use it when:
* No existing tool can fulfill the user's request
* The user explicitly asks for functionality that doesn't exist yet
* The user encounters a limitation that no combination of available tools can work around
Do NOT use this tool if an existing tool can handle the request, even partially.
The feature request will be reviewed by the Coalesce Quality product team.
| Flag | Type | Default | Description |
| ----------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--description` | `string` | — | \[required] A clear description of what the user needs, including context about what they were trying to accomplish and why the current tools are insufficient. Only populate this when no existing tool can fulfill the request (max 4096 characters). |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools summarise_executions`
```bash theme={null}
synq-scout tools summarise_executions [flags]
```
Get aggregated execution statistics for specified entities.
Provides execution counts by type and status, time range of executions, and latest execution per entity.
Use this to quickly understand execution patterns without fetching all execution details.
| Flag | Type | Default | Description |
| ---------------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--entity-ids` | `stringArray` | — | Entity identifiers to get summary for (required) |
| `--execution-started-after` | `string` | — | Return executions that started after this timestamp. If not provided, derived from lookback\_days (see below), and if that is also unset defaults to execution\_started\_before minus 3 days. |
| `--execution-started-before` | `string` | — | Return executions that started before this timestamp If not provided, defaults to now() |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--lookback-days` | `int64` | — | Convenience time window: return executions from the last N days. Prefer this over execution\_started\_after for simple "recent" lookups — execution\_started\_after is computed as (execution\_started\_before or now()) minus lookback\_days days. Ignored when execution\_started\_after is set explicitly. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
#### `synq-scout tools update_incident`
```bash theme={null}
synq-scout tools update_incident [flags]
```
Edit an existing incident. Any subset of optional fields may be provided;
only the supplied fields are changed. Use this to rename the incident,
change its state, reassign the owner, or attach/detach issues — all in a
single call. Leave fields unset to keep their current value.
| Flag | Type | Default | Description |
| -------------------- | ------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--add-issue-ids` | `stringArray` | — | Issue IDs to attach to the incident. Issues already attached are a no-op. |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--incident-id` | `string` | — | \[required] Unique identifier of the incident to edit. |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--name` | `string` | — | New name/title for the incident. Leave unset to keep the current name. |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--owner-email` | `string` | — | Reassign the incident owner to the user with this email. The email must exactly match an existing workspace user — the backend lookup is case-sensitive and does not auto-provision new users. Discover valid emails via the 'list\_users' tool. Set to an empty string to unassign the current owner. Leave unset to keep the current owner. |
| `--remove-issue-ids` | `stringArray` | — | Issue IDs to detach from the incident. Issues not currently attached are a no-op. |
| `--state` | `string` | — | \[required] New state for the incident. Leave unset (or set to INCIDENT\_STATE\_UNSPECIFIED) to keep the current state. (one of: open, closed, cancelled) |
#### `synq-scout tools update_monitors`
```bash theme={null}
synq-scout tools update_monitors [flags]
```
UpdateMonitors updates monitors by id. Each monitor is a FULL REPLACE, not a
patch: send the complete object from list\_monitors with your edits applied —
any field you omit is cleared, not preserved. Reset-triggering changes
(schedule, time-partitioning, segmentation, timezone, custom-numeric
aggregation) and overwrites of UI/other-config monitors are gated — see
service docs.
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--monitors` | `string` | — | Complete monitor objects to replace by id (full replace, not a patch — fetch from list\_monitors, apply edits, send the whole object; omitted fields are cleared). (JSON array) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting despite UI/other-config ownership. Populate only after the user approved the listed ids. |
| `--reset-confirmed-ids` | `stringArray` | — | Ids the USER confirmed resetting (a reset retrains the monitor's anomaly baseline from scratch; past run results are kept). Populate only after the user approved the listed ids. |
#### `synq-scout tools update_sql_tests`
```bash theme={null}
synq-scout tools update_sql_tests [flags]
```
UpdateSqlTests updates SQL tests by id. Each test is a FULL REPLACE, not a
patch: send the complete object from list\_sql\_tests with your edits applied —
any field you omit is cleared, not preserved. Reset-triggering changes
(recurrence, severity, evaluators, test template/type) and overwrites of
UI/other-config tests are gated.
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting despite UI/other-config ownership. Populate only after the user approved the listed ids. |
| `--reset-confirmed-ids` | `stringArray` | — | Ids the USER confirmed resetting (a reset re-runs the test with the new definition; past results are kept, nothing is deleted). Populate only after the user approved the listed ids. |
| `--sql-tests` | `string` | — | Complete SQL-test objects to replace by id (full replace, not a patch — fetch from list\_sql\_tests, apply edits, send the whole object; omitted fields are cleared). (JSON array) |
#### `synq-scout tools update_table_stats_monitor`
```bash theme={null}
synq-scout tools update_table_stats_monitor [flags]
```
UpdateTableStatsMonitor updates a table-stats monitor by id and redeploys.
This is a FULL REPLACE, not a patch: fetch the monitor from
list\_table\_stats\_monitors, apply your edits, and send the COMPLETE metric set
— any metric you omit is removed. Table-stats have no reset concept;
overwrites of UI/other-config rules are gated.
| Flag | Type | Default | Description |
| --------------------------- | ------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `-d`, `--dry-run` | `bool` | `true` | Drop non-NO\_SIDE\_EFFECTS (write) calls before they reach the backend; read calls always pass through |
| `--id` | `string` | — | \[required] |
| `--json` | `string` | — | Supply all arguments as a single JSON object (mutually exclusive with the per-argument flags) |
| `--metrics` | `string` | — | The COMPLETE set of metrics for this monitor (full replace, not a patch): any metric present on the monitor but omitted here is removed. Fetch the current set from list\_table\_stats\_monitors first. (JSON array) |
| `-o`, `--output` | `string` | `json` | Output format: json, yaml, toon |
| `--overwrite-confirmed-ids` | `stringArray` | — | Ids the USER confirmed overwriting despite UI/other-config ownership. Populate only after the user approved the listed ids. |
| `--sensitivity` | `string` | — | \[required] (one of: SENSITIVITY\_UNSPECIFIED, SENSITIVITY\_PRECISE, SENSITIVITY\_BALANCED, SENSITIVITY\_RELAXED) |
| `--severity` | `string` | — | \[required] (one of: SEVERITY\_UNSPECIFIED, SEVERITY\_WARNING, SEVERITY\_ERROR, SEVERITY\_INFO) |
| `--title` | `string` | — | Optional display title. Preserves the existing rule's title when unset. |