Scout CLI reference - Coalesce Quality Documentation

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; for using its tools from an MCP client, see 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:

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

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

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:

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)

Authenticate with Coalesce Quality in a browser

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:

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

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

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

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:

curl -H "Authorization: Bearer $(synq-scout auth token)" ...

`synq-scout auth whoami`

Show who you are authenticated as and which permissions are granted

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

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`

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

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

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

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

synq-scout tools

Expose the same tools the MCP server serves as one-shot CLI commands.

synq-scout tools list                       list available tools
synq-scout tools describe <tool>            show a tool's description and schemas
synq-scout tools <tool> --<arg> <value>     invoke a tool via typed flags
synq-scout tools <tool> --json '{...}'      invoke a tool via a raw JSON argument object

Arguments can be supplied either as individual —<arg> flags (derived from the tool’s input schema) or as a single —json object, but not both at once.

`synq-scout tools add_comment`

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`

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`

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`

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`

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`

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`

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`

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`

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 “<asset> table stats” when unset.

`synq-scout tools delete_data_product`

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-<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
`--purge`	`bool`	—	[required] Hard-delete instead of soft-delete, releasing the id for reuse.

`synq-scout tools delete_deployment_rule`

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`

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-<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
`--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`

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`

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-<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
`--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`

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`

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`

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`

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

synq-scout tools describe <tool>

`synq-scout tools describe_check_types`

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`

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`

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`

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`

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`

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`

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`

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-<uuid>’). 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`

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`

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`

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`

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-<uuid>’). 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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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-<uuid>’). 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`

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`

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`

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`

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`

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:

- 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

synq-scout tools list

`synq-scout tools list_annotations`

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`

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`

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`

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-<uuid>’).
`--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`

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`

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`

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`

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-<uuid>’).
`--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`

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`

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`

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`

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`

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`

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`

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`

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`

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-<uuid>’). 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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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-<uuid>’). 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`

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-<uuid>’). 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-<uuid>’). 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`

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-<uuid>’). 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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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.

MCP Ownership overview

​Commands

​synq-scout agent

​synq-scout auth

​synq-scout auth login

​synq-scout auth logout

​synq-scout auth status

​synq-scout auth token

​synq-scout auth whoami

​synq-scout health

​synq-scout issue

​synq-scout mcp

​synq-scout sre

​synq-scout tester

​synq-scout tools

​synq-scout tools add_comment

​synq-scout tools batch_entity_details

​synq-scout tools batch_executions

​synq-scout tools batch_urls

​synq-scout tools browse_folders

​synq-scout tools create_incident

​synq-scout tools create_monitors

​synq-scout tools create_sql_tests

​synq-scout tools create_table_stats_monitor

​synq-scout tools delete_data_product

​synq-scout tools delete_deployment_rule

​synq-scout tools delete_domain

​synq-scout tools delete_monitors

​synq-scout tools delete_owner

​synq-scout tools delete_saved_view

​synq-scout tools delete_sql_tests

​synq-scout tools delete_table_stats_monitor

​synq-scout tools deploy_deployment_rule

​synq-scout tools describe

​synq-scout tools describe_check_types

​synq-scout tools describe_resolver_ql

​synq-scout tools execute_monitor

​synq-scout tools folder_of

​synq-scout tools get_code

​synq-scout tools get_commit_diff

​synq-scout tools get_common_upstream_dependencies

​synq-scout tools get_data_product

​synq-scout tools get_database_change_details

​synq-scout tools get_database_coordinates_from_entity

​synq-scout tools get_deployment_rule

​synq-scout tools get_domain

​synq-scout tools get_downstream_dependencies

​synq-scout tools get_entity_details

​synq-scout tools get_entity_from_database_coordinates

​synq-scout tools get_entity_impact

​synq-scout tools get_entity_metrics

​synq-scout tools get_immediate_downstream_dependencies

​synq-scout tools get_immediate_upstream_dependencies

​synq-scout tools get_incident_details

​synq-scout tools get_issue

​synq-scout tools get_issue_comments

​synq-scout tools get_issue_details

​synq-scout tools get_issue_impact

​synq-scout tools get_latest_executions

​synq-scout tools get_lineage

​synq-scout tools get_monitor

​synq-scout tools get_monitor_predictions

​synq-scout tools get_orchestration

​synq-scout tools get_owner

​synq-scout tools get_saved_view

​synq-scout tools get_schema

​synq-scout tools get_upstream_dependencies

​synq-scout tools get_upstream_sources

​synq-scout tools iam

​synq-scout tools list

​synq-scout tools list_annotations

​synq-scout tools list_checks

​synq-scout tools list_commits

​synq-scout tools list_data_product_members

​synq-scout tools list_data_products

​synq-scout tools list_database_changes

​synq-scout tools list_deployment_rules

​synq-scout tools list_domain_members

​synq-scout tools list_domains

​synq-scout tools list_executions

​synq-scout tools list_folder_members

Commands

`synq-scout agent`

`synq-scout auth`

`synq-scout auth login`

`synq-scout auth logout`

`synq-scout auth status`

`synq-scout auth token`

`synq-scout auth whoami`

`synq-scout health`

`synq-scout issue`

`synq-scout mcp`

`synq-scout sre`

`synq-scout tester`

`synq-scout tools`

`synq-scout tools add_comment`

`synq-scout tools batch_entity_details`

`synq-scout tools batch_executions`

`synq-scout tools batch_urls`

`synq-scout tools browse_folders`

`synq-scout tools create_incident`

`synq-scout tools create_monitors`

`synq-scout tools create_sql_tests`

`synq-scout tools create_table_stats_monitor`

`synq-scout tools delete_data_product`

`synq-scout tools delete_deployment_rule`

`synq-scout tools delete_domain`

`synq-scout tools delete_monitors`

`synq-scout tools delete_owner`

`synq-scout tools delete_saved_view`

`synq-scout tools delete_sql_tests`

`synq-scout tools delete_table_stats_monitor`

`synq-scout tools deploy_deployment_rule`

`synq-scout tools describe`

`synq-scout tools describe_check_types`

`synq-scout tools describe_resolver_ql`

`synq-scout tools execute_monitor`

`synq-scout tools folder_of`

`synq-scout tools get_code`

`synq-scout tools get_commit_diff`

`synq-scout tools get_common_upstream_dependencies`

`synq-scout tools get_data_product`

`synq-scout tools get_database_change_details`

`synq-scout tools get_database_coordinates_from_entity`

`synq-scout tools get_deployment_rule`

`synq-scout tools get_domain`

`synq-scout tools get_downstream_dependencies`

`synq-scout tools get_entity_details`

`synq-scout tools get_entity_from_database_coordinates`

`synq-scout tools get_entity_impact`

`synq-scout tools get_entity_metrics`

`synq-scout tools get_immediate_downstream_dependencies`

`synq-scout tools get_immediate_upstream_dependencies`

`synq-scout tools get_incident_details`

`synq-scout tools get_issue`

`synq-scout tools get_issue_comments`

`synq-scout tools get_issue_details`

`synq-scout tools get_issue_impact`

`synq-scout tools get_latest_executions`

`synq-scout tools get_lineage`

`synq-scout tools get_monitor`

`synq-scout tools get_monitor_predictions`

`synq-scout tools get_orchestration`

`synq-scout tools get_owner`

`synq-scout tools get_saved_view`

`synq-scout tools get_schema`

`synq-scout tools get_upstream_dependencies`

`synq-scout tools get_upstream_sources`

`synq-scout tools iam`

`synq-scout tools list`

`synq-scout tools list_annotations`

`synq-scout tools list_checks`

`synq-scout tools list_commits`

`synq-scout tools list_data_product_members`

`synq-scout tools list_data_products`

`synq-scout tools list_database_changes`

`synq-scout tools list_deployment_rules`

`synq-scout tools list_domain_members`

`synq-scout tools list_domains`

`synq-scout tools list_executions`

`synq-scout tools list_folder_members`