Support

Agent, connector and control-plane error codes

Error codes are fixed, value-free identifiers: they never contain source values, host names or credentials, so they are safe to search for and to quote to support.

Showing 624 of 624 codes.

Agent codes

Job codes appear on the failed job in the console and in the agent’s JSON logs. Some job codes come straight from an engine validation or certification gate; the job’s evidence names the gate.

AGENT_CONFIG_INVALID — Agent configuration invalid

The agent's local configuration or state files are invalid.

What to do: Run `datanivra-agent check` to see which setting is rejected, fix the DATANIVRA_AGENT_* variable and restart.

AGENT_ERROR — Unclassified agent error

A generic agent failure without a more specific code.

What to do: Check the agent's JSON logs around the time of the failure; if it repeats, contact support with the job id and the code.

AGENT_KEY_INVALID — Agent key invalid

The agent's private key file is not a valid Ed25519 key.

What to do: Restore the key from the agent's state volume backup, or revoke the agent in the console and enroll a new one.

AGENT_KEY_NOT_CREATED — Agent key not created yet

The doctor found no private key: the agent generates it (mode 0600) the first time it starts.

What to do: Nothing to do before the first start; run the doctor again after the agent has started once.

Operator runbook: docs/runbooks/agent-doctor.md

AGENT_KEY_PERMISSIONS — Agent key file too open

The private key file is readable by users other than the agent (it must be mode 0600).

What to do: Run `chmod 600` on the key file in the state directory and make sure it is owned by the agent user.

AGENT_NOT_ENROLLED — Agent not enrolled

The agent tried to call the control plane before enrolling.

What to do: Create an enrollment token in the console, provide it through DATANIVRA_AGENT_ENROLLMENT_TOKEN_REF and run `datanivra-agent enroll` (or `run`).

AGENT_PACK_MISSING — Industry pack not installed on the agent

The job is pinned to an industry pack this agent does not have.

What to do: Upgrade the agent to a release that ships the pack, then run the request again.

AGENT_PACK_VERSION_INCOMPATIBLE — Industry pack version differs on the agent

The agent holds a different version of the pack than the one the job was approved for.

What to do: Deploy an agent with the pack's active version, or roll the pack back in Industry packs.

AGENT_REVOKED — Agent revoked

The control plane revoked this agent; it stops all work and publishes nothing.

What to do: If the revocation was intended, uninstall the agent. Otherwise enroll a new agent with a fresh enrollment token.

Operator runbook: docs/runbooks/agent-offline.md

AGENT_VERSION_INVALID — Agent version not comparable

The agent version or the control plane's minimum agent version is not a semantic version, so support cannot be confirmed.

What to do: Use an official agent release image; if it persists, contact support with both version strings.

Operator runbook: docs/runbooks/agent-doctor.md

AGENT_VERSION_UNSUPPORTED — Agent version below the minimum

The control plane requires a newer agent than the one running (learnt from the last heartbeat).

What to do: Upgrade the agent to a release at or above the minimum shown, pinned by digest (see /downloads).

Operator runbook: docs/runbooks/agent-doctor.md

ALREADY_ENROLLED — Agent already enrolled

The agent already has an identity, so its one-time enrollment token is no longer used or checked.

What to do: Nothing to do. You may delete the enrollment token secret.

Operator runbook: docs/runbooks/agent-doctor.md

CA_BUNDLE_UNREADABLE — CA bundle unreadable

DATANIVRA_AGENT_CA_BUNDLE points to a file that is missing or is not a valid PEM bundle.

What to do: Mount the corporate CA bundle into the agent and point DATANIVRA_AGENT_CA_BUNDLE at it.

Operator runbook: docs/runbooks/agent-doctor.md

CERTIFICATION_FAILED — Certification failed

One or more certification gates failed, so the dataset version cannot be published or provisioned.

What to do: Open the job's evidence in the console to see which gate failed (for example an uncovered sensitive column), fix the policy and request a new version.

CERTIFICATION_POLICY_CONTENT_MISSING — Certification policy content missing

The job did not carry the certification policy content it referenced.

What to do: Re-submit the request; if it repeats, check that the certification policy version is approved.

Operator runbook: docs/runbooks/expired-policy.md

CLASSIFICATION_POLICY_CONTENT_MISSING — Classification policy content missing

The job did not carry the classification policy content it referenced.

What to do: Re-run discovery; if it repeats, check that an approved classification policy exists.

Operator runbook: docs/runbooks/expired-policy.md

CLOCK_REFERENCE_UNAVAILABLE — No control-plane time to compare

The clock check had no control-plane time: the health check did not answer and no heartbeat has been acknowledged yet.

What to do: Fix the control-plane checks first, or run the doctor again after the agent has sent a heartbeat.

Operator runbook: docs/runbooks/agent-doctor.md

CLOCK_SKEW — Clock skew

The agent's clock differs from the control plane's by more than 30 seconds (a failure above clock_skew_tolerance_seconds). Command expiry and lease checks use the local clock.

What to do: Enable NTP time synchronisation on the agent host or Kubernetes nodes.

Operator runbook: docs/runbooks/agent-doctor.md

CLOSURE_*_EXCEEDED — Subset closure bound exceeded

The entity-graph closure would pull in more rows than the subset definition allows: CLOSURE_FAN_OUT_EXCEEDED (one key reaches more rows than max_fan_out across one relationship; the relationship id is recorded locally) or CLOSURE_ROW_BUDGET_EXCEEDED (more than max_selected_rows in total). Nothing was published.

What to do: Narrow the root selection, exclude the exploding relationship, review the identity link that fans out, or raise the bound deliberately.

CLOSURE_BOUNDS_SPARK_UNSUPPORTED — Closure bounds need the local backend

The subset definition sets a fan-out or row budget, which the Spark subset backend does not enforce yet, so the job was refused instead of ignoring the bound.

What to do: Run the job on the local subset backend, or remove max_fan_out / max_selected_rows from the subset definition.

COMMAND_EXPIRED — Command expired

A leased command reached the agent after its validity window.

What to do: Usually caused by a stopped or slow agent. Check agent health and clock synchronisation, then retry.

Operator runbook: docs/runbooks/agent-offline.md

COMMAND_INVALID — Command invalid

A leased command failed local validation (for example a missing job id).

What to do: Retry the request. If it repeats, contact support with the job id.

COMMAND_NOT_EXECUTABLE — Command not executable

The agent received a command type that is not a job.

What to do: Upgrade the agent to the release that matches your control plane.

COMMAND_REJECTED — Command rejected

A leased command failed local validation and was refused (fail closed).

What to do: Check the job's error details in the console; upgrade the agent if it is older than the control plane.

CONNECTOR_INVALID — Connector plugin invalid

A connector factory returned an object that is not a connector.

What to do: Remove or fix the connector plugin installed in your custom agent image.

CONNECTOR_KIND_MISMATCH — Connector kind mismatch

The --connector kind given to the doctor differs from the kind declared in the source connection document.

What to do: Pass the kind the connection document declares, or fix the document's kind field.

Operator runbook: docs/runbooks/agent-doctor.md

CONNECTORS_NOT_CONFIGURED — No connectors configured

The agent has no connector factory configured.

What to do: Use the standard agent image, which registers the built-in connectors, or fix a customised image.

CONTROL_PLANE_DNS_FAILED — Control-plane host does not resolve

The host name of DATANIVRA_AGENT_CONTROL_PLANE_URL could not be resolved from the agent's network.

What to do: Check the URL and the agent's DNS; allow resolution of the control-plane host (or configure HTTPS_PROXY).

Operator runbook: docs/runbooks/agent-doctor.md

CONTROL_PLANE_PORT_BLOCKED — Outbound port blocked

A TCP connection from the agent to the control plane's port (443 by default) could not be opened.

What to do: Allow outbound HTTPS from the agent network to the control-plane host, or configure HTTPS_PROXY.

Operator runbook: docs/runbooks/agent-doctor.md

CONTROL_PLANE_UNAVAILABLE — Control plane unreachable

The agent could not reach the control plane or earlier reports are still queued. Reports are retried from the local outbox.

What to do: Check outbound HTTPS (443) from the agent host, proxy settings and ca_bundle. The agent keeps retrying.

Operator runbook: docs/runbooks/control-plane-unavailable.md

CONTROL_PLANE_UNHEALTHY — Control plane unhealthy

The control plane answered its liveness endpoint with a non-200 status.

What to do: Retry later and check the status page; a 3xx answer means the URL is wrong (the agent never follows redirects).

Operator runbook: docs/runbooks/agent-doctor.md

CUSTOM_SCHEMA_ENGINE_UNSUPPORTED — Engine cannot build from a custom schema

The agent's engine does not support custom schemas, so it refused the job instead of building something else.

What to do: Upgrade the agent to a release that advertises custom-schema support, then run the request again.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_INTEGRITY_MISMATCH — Custom schema failed its integrity check

The structure in the job does not match its pinned fingerprint, so the agent refused to build from it (fail closed).

What to do: Run the request again. If it repeats, contact support with the correlation id: the job was not built.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_ROOT_REQUIRED — Scenario has no root table

A custom-schema scenario reached the agent without the root table it should generate.

What to do: Name a root_table for every scenario of the profile or dataset request.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_SYNTHETIC_ONLY — Custom schema combined with sources or packs

A custom schema is used only for synthetic-only builds without sources or industry packs.

What to do: Remove the sources and industry pack from the request, or use a pack instead of the custom schema.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_TABLE_UNKNOWN — Root table not in the custom schema

A scenario's root table is not a table of the pinned custom schema version.

What to do: Check the scenario's root_table against the custom schema version the profile pins.

Operator runbook: docs/runbooks/test-data-api.md

DANGLING_REFERENCES — Subset not referentially intact

The distributed subset left references pointing at rows that were not included.

What to do: Review the subset definition's relationships (add the missing relationship or include the parent table) and run the job again.

DATASET_INTEGRITY_FAILED — Dataset integrity check failed

A published dataset file or its evidence is missing or does not match the manifest.

What to do: Treat the version as unusable: request a new version. Investigate who changed files in the datasets directory.

Operator runbook: docs/runbooks/corrupt-manifest.md

DATASET_NOT_ACCEPTED — Dataset not accepted

The control plane never accepted this dataset version, so it cannot be provisioned.

What to do: Request a new version and check that the certification report was delivered.

Operator runbook: docs/runbooks/partial-evidence-upload.md

DATASET_NOT_PROVISIONABLE — Dataset not provisionable

Only certified versions can be provisioned; this version is not certified.

What to do: Certify a new version first. Failed or revoked versions never provision.

Operator runbook: docs/runbooks/revoked-dataset.md

DATASET_NOT_PUBLISHED_LOCALLY — Dataset not on this agent

The dataset version is not published on the agent asked to provision it.

What to do: Provision from the agent that built the version, or rebuild it on this agent.

DATASET_REVOKED — Dataset revoked

The dataset version was revoked, so it cannot be used.

What to do: Request a new version.

Operator runbook: docs/runbooks/revoked-dataset.md

DATASET_VERSION_EXISTS — Dataset version already exists

Dataset versions are immutable; this version was already published.

What to do: Request a new version instead of rebuilding an existing one.

Operator runbook: docs/runbooks/duplicate-refresh.md

DATASETS_DIR_NOT_EGRESS_SAFE — Datasets directory path unsafe

The configured datasets directory path would itself be flagged by the egress guard if reported.

What to do: Choose a datasets directory whose path does not contain personal or data-derived names.

DELIVERY_NOT_AUTHORIZED — Delivery not authorized

A provisioning command arrived that does not authorize writing the target environment, so nothing was written.

What to do: Provision the version again from the console; if it repeats, contact support.

DEPENDENCY_FAILED — Check skipped

The doctor skipped this check because a check it depends on failed or could not run.

What to do: Fix the earlier failed check and run the doctor again.

Operator runbook: docs/runbooks/agent-doctor.md

DEPROVISION_INCOMPLETE — Deprovisioning incomplete

Some target environments could not be cleaned up.

What to do: Check target connectivity and permissions, then retry deprovisioning.

Operator runbook: docs/runbooks/target-unavailable.md

DETECTOR_ADAPTER_* — Detector adapter refused

A pluggable span-detector adapter was refused: DETECTOR_ADAPTER_POLICY_REQUIRED (adapters stay disabled until a policy enables them), DETECTOR_ADAPTER_INVALID, DETECTOR_ADAPTER_DUPLICATE or DETECTOR_ADAPTER_CONTRACT_VIOLATION (it returned malformed spans). No adapter ships; deterministic rules run by default.

What to do: Detector adapters need owner approval (licence and model provenance); leave them disabled unless approved.

DISTRIBUTED_EXECUTION_UNAVAILABLE — Distributed execution unavailable

The Spark backend is configured but not installed in this agent image.

What to do: Install the distributed execution extra in your agent image, or switch back to the local backend.

DISTRIBUTED_TYPE_MISMATCH — Distributed column type changed

A column's type changed during distributed processing.

What to do: Check for schema drift in the source and re-run discovery before the job.

Operator runbook: docs/runbooks/schema-drift.md

DOCUMENT_KIND_UNKNOWN — Unknown synthetic document kind

The synthetic document generator was asked for a kind it does not know.

What to do: Use one of the documented kinds (EMAIL, CHAT, TICKET, CLINICAL_NOTE, NOTE).

DOCUMENT_PARSE_REJECTED — Document could not be parsed safely

A document of a document set was malformed or hostile (for example a zip bomb, a macro-enabled DOCX, an XML DTD, invalid UTF-8 or a limit exceeded) and the hardened parsers rejected it. With document_on_rejected: fail (the default) the job fails closed.

What to do: Remove or repair the document, or set document_on_rejected: skip in the connection document to leave rejected documents out (the DOCUMENT_PARSE gate records the count).

DOCUMENT_SET_ALREADY_PUBLISHED — Document set output already exists

The engine refused to overwrite an existing published document-set output directory.

What to do: Use a new output directory or a new dataset version.

DOCUMENT_SET_PATH_INVALID — Scan path is not a directory

datanivra-agent documents scan was given a path that is not a directory.

What to do: Pass the directory that holds the documents.

DOCUMENT_SET_SOURCE_MISMATCH — Source is not a document set

The control plane registered the source as DOCUMENTS but its customer-side connection document does not say format: documents. The job failed closed.

What to do: Set format: documents in the connection document, or register the source as TABLES.

DOCUMENT_SET_SUMMARY_MISSING — Document set was not scanned

The command named a DOCUMENTS source but the build produced no document-set summary (for example the masking policy has no TEXT_SPAN_MASK rule). The job failed closed.

What to do: Use a masking policy with a TEXT_SPAN_MASK rule on the text column of the documents table and rebuild.

DOCUMENT_SET_TOO_LARGE — Document set exceeds its limit

The document set holds more documents than the configured per-set limit.

What to do: Split the set into several sources or narrow the root directory.

DOCUMENT_TOO_LARGE — Document exceeds a size limit

A document exceeded the per-document byte, part or character limits of the document-set parser and was rejected.

What to do: Split the document or remove it from the set; the limits protect the agent from resource exhaustion.

DOCUMENT_TYPE_UNSUPPORTED — Document type not supported

A file in the document set is not txt, md, log, json, jsonl, eml or docx. PDF and legacy Office formats are not parsed.

What to do: Convert the file to a supported format, remove it, or use document_on_rejected: skip. A PDF extractor is an optional extra that needs owner approval.

EGRESS_BLOCKED — Report blocked by EgressGuard

The agent's EgressGuard refused to send a message because it looked like it could contain data values. Nothing was sent.

What to do: Inspect the local log with `datanivra-agent violations` (codes and hashes only) and follow the egress-violation runbook.

Operator runbook: docs/runbooks/egress-violation.md

ENGINE_ADAPTER_INVALID — Engine adapter invalid

The configured engine adapter failed to build or does not implement the engine interface.

What to do: Reset DATANIVRA_AGENT_ENGINE_ADAPTER to its default or fix the custom adapter.

ENGINE_ADAPTER_UNAVAILABLE — Engine adapter unavailable

The configured engine adapter module could not be loaded.

What to do: Use the standard agent image or install the adapter module you configured.

ENGINE_OUTPUT_INVALID — Engine output invalid

A stage output table path is missing or outside its stage directory.

What to do: Retry the job; if it repeats, keep the failed workspace (keep_failed_workspaces) and contact support with the code.

Operator runbook: docs/runbooks/masking-crash.md

ENGINE_OUTPUT_OUTSIDE_STAGE — Engine output outside stage

A stage wrote its output somewhere other than its own stage directory.

What to do: Retry; if it repeats, contact support with the job id.

Operator runbook: docs/runbooks/masking-crash.md

ENGINE_OUTPUT_SPECIAL_FILE — Stage output holds a special file

A stage wrote something other than regular files and directories (a FIFO, socket or device) into its output. The agent refuses it before opening anything, so nothing is certified or published.

What to do: Report the job id to support: engine stages only write regular files. If the stage ran isolated, treat it as a possibly compromised stage.

ENGINE_STAGE_FAILED — Engine stage failed

An engine stage (discover, subset, mask, synthesize, validate, certify) failed without a more specific code.

What to do: Look at the job step that failed in the console and retry. Keep the failed workspace for local forensics if needed.

Operator runbook: docs/runbooks/masking-crash.md

ENROLLMENT_TOKEN_REF_MISSING — Enrollment token reference missing

The agent needs to enroll but no enrollment token reference is configured.

What to do: Set DATANIVRA_AGENT_ENROLLMENT_TOKEN_REF to a secret reference (for example env://DATANIVRA_ENROLLMENT_TOKEN) holding a fresh token.

ENVIRONMENT_EXPIRED — Environment expired

The target environment's expiry (or the two-minute safety margin before it) was reached before the agent wrote the data, so nothing was written.

What to do: Extend or recreate the environment, then provision the version again.

EVAL_SET_GENERATION_FAILED — Eval-set generation failed

datanivra-agent eval-set generate could not build a bundle that verifies against its own manifest; nothing was written.

What to do: Check the generation arguments (per-kind, answerable, per-adversarial) and the agent version.

FINDING_REVIEWS_CHECKSUM_MISMATCH — Finding reviews checksum mismatch

The reviewed findings attached to a job do not match their checksum.

What to do: Re-submit the request so the control plane attaches a consistent snapshot.

GUARD_REF_KEY_INVALID — Guard reference key unreadable

The agent's customer-resident key for a guarded environment's opaque table and column references exists but is damaged, so the compliance scan stopped instead of producing references that would not match earlier scans.

What to do: Remove the environment's key file under the agent state directory (guard-ref-keys/) to rotate the key, then request a new scan; the control plane replaces the per-table baseline after a key rotation.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SESSION_NOT_READ_ONLY — Scan session is not read-only

The agent could not confirm that its PostgreSQL session for a compliance scan is read-only, so it scanned nothing.

What to do: Check that the scan credential may set default_transaction_read_only (no role setting forces it off) and retry; prefer a dedicated read-only credential as the scan reference.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_TARGET_UNSUPPORTED — Guarded environment kind not scannable

The scan reference resolves to a target kind the compliance scan cannot read (it supports POSTGRESQL and DIRECTORY targets). Nothing was read.

What to do: Point the guarded environment's scan reference at a POSTGRESQL or DIRECTORY target document, or upgrade the agent to a release that scans this kind.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_TIER_NOT_COVERED — Scan refused: tier not covered

The agent refused a compliance scan because the guard policy version it received has no rule for the environment's tier (fail closed).

What to do: Add a rule for the tier in a new version of the COMPLIANCE_GUARD policy, approve it, and request the scan again.

Operator runbook: docs/runbooks/compliance-guard.md

HTTP_* — Control plane HTTP status

The control plane answered with the given HTTP status. 429/502/503/504 are retried from the outbox.

What to do: For 4xx statuses other than 429, check agent version compatibility; for 5xx, wait and let the agent retry.

HTTP_429 — Control plane rate limit (HTTP 429)

The control plane asked the agent to slow down. Reports are retried from the outbox.

What to do: No action normally needed. If it persists, reduce concurrent jobs on the agent.

HTTP_502 — Bad gateway (HTTP 502)

A proxy or gateway between the agent and the control plane failed. Reports are retried.

What to do: Check any outbound proxy; the agent retries automatically.

Operator runbook: docs/runbooks/control-plane-unavailable.md

HTTP_503 — Service unavailable (HTTP 503)

The control plane was temporarily unavailable. Reports are retried.

What to do: Wait and let the agent retry; check the control plane's health if it persists.

Operator runbook: docs/runbooks/control-plane-unavailable.md

HTTP_504 — Gateway timeout (HTTP 504)

A proxy or gateway timed out. Reports are retried.

What to do: Check proxy timeouts; the agent retries automatically.

Operator runbook: docs/runbooks/control-plane-unavailable.md

IDENTITY_GRAPH_SPARK_UNSUPPORTED — Identity links need the local engine

The dataset job carries approved cross-system identity links, which the Spark execution backend does not apply yet; the job stopped instead of producing unlinked data.

What to do: Run the job on the local engine backend, or remove the identity links from this dataset request.

IDENTITY_OVERLAP_RESULT_MISMATCH — Overlap results incomplete

The engine did not return exactly one result per requested link, so nothing was reported.

What to do: Run the measurement again; if it repeats, contact support with the job id.

IDENTITY_OVERLAP_UNSUPPORTED — Engine cannot measure identity overlap

The agent's engine does not implement value-assisted matching.

What to do: Upgrade the agent; agents that support it advertise the IDENTITY_OVERLAP capability.

IDENTITY_SOURCE_NOT_IN_JOB — Link names a source outside the job

A value-assisted matching command named a link whose source is not part of the command.

What to do: Request the measurement again from the console; do not hand-craft commands.

INDUSTRY_PACK_* — Industry pack unusable

An installed industry pack reported a problem; the part after INDUSTRY_PACK_ is the pack's own reason code.

What to do: Check the pack version installed in the agent image and its compatibility with your policy.

INDUSTRY_PACK_NOT_ENTITLED — Industry pack not licensed

The job needs an industry pack that your plan or license does not include.

What to do: Enable the pack on a plan that includes it (see Billing & Plan in the console) or remove it from the policy.

INDUSTRY_PACK_NOT_INSTALLED — Industry pack not installed

The job needs an industry pack that is not installed in this agent image.

What to do: Use an agent image that includes the pack, or remove the pack from the policy.

INSECURE_HTTP — Control plane over plain HTTP

The control-plane URL uses http://, which is allowed only for local demos and tests.

What to do: Use the https:// control-plane URL and unset DATANIVRA_AGENT_ALLOW_INSECURE_HTTP.

Operator runbook: docs/runbooks/agent-doctor.md

ISOLATED_KEY_NOT_PERMITTED — Worker asked for a key outside the job's policy

An isolated stage requested a key reference the job's masking policy does not name. It was refused and the job failed closed.

What to do: Report the job id to support: legitimate stages only use the policy's keys.

ISOLATED_MESSAGE_TOO_LARGE — Isolated stage message too large

A stage manifest or result exceeded the 32 MiB frame limit.

What to do: Reduce very large policies or custom schemas; contact support if it persists.

ISOLATED_OUTPUT_REJECTED — Isolated worker output refused

The microVM worker's output archive contained something other than regular files and directories, an unsafe path, or more data than the output limit. Nothing was promoted or published.

What to do: Report the job id to support: legitimate stages only write regular files. Raise the output limit only for very large datasets.

ISOLATED_STAGE_TIMEOUT — Isolated stage timed out

An isolated stage exceeded DATANIVRA_AGENT_ISOLATION_STAGE_TIMEOUT_SECONDS and its worker was stopped.

What to do: Increase the stage timeout for very large datasets, or reduce the subset.

ISOLATED_SUPERVISOR_GONE — Supervisor closed the worker channel

The agent stopped the worker (shutdown, cancellation or timeout) while it was working.

What to do: No action: the job reports why it stopped.

ISOLATED_WORKER_CRASHED — Isolated worker ended without a result

The worker exited without reporting a result (killed, crashed or the runtime stopped it). Nothing was published.

What to do: Check host resources and `datanivra-agent isolation status`; retry the job.

ISOLATED_WORKER_OOM_KILLED — Isolated worker out of memory

The worker exceeded DATANIVRA_AGENT_ISOLATION_MEMORY_BYTES and was stopped by the memory limit.

What to do: Raise the worker memory limit or reduce the dataset size.

ISOLATED_WORKER_PACK_MISMATCH — Worker industry packs differ

The worker image holds different industry pack versions than the agent for this job.

What to do: Use this agent's own image digest for the worker.

ISOLATED_WORKER_PROTOCOL_VIOLATION — Isolated worker broke the protocol

The worker sent something the supervisor does not accept (unknown message, malformed or out-of-place result). The stage failed closed.

What to do: Make sure the worker image is this agent's own image; report the job id to support (this can indicate a compromised stage).

ISOLATED_WORKER_VERSION_MISMATCH — Worker engine version differs

The worker image runs a different engine version than the agent; mixing them would break certification.

What to do: Set DATANIVRA_AGENT_ISOLATION_IMAGE to the digest of this agent's own release.

ISOLATION_BACKEND_NOT_IMPLEMENTED — Isolation backend not available

The selected isolation backend cannot run on this build or host.

What to do: Select OCI or GVISOR, or see docs/architecture/firecracker-feasibility.md.

ISOLATION_BACKEND_STAGE_UNSUPPORTED — Stage not supported by this backend

The backend cannot run this stage (for example the Firecracker backend has no network device, so it cannot read network sources or provision network targets).

What to do: Use the OCI or GVISOR backend for jobs with network sources or targets.

ISOLATION_ENGINE_UNSUPPORTED — Engine backend cannot run isolated

The distributed (Spark) engine backend cannot run inside isolated workers.

What to do: Use the local engine backend with isolation, or run Spark jobs on an agent without an isolation backend.

ISOLATION_FIRECRACKER_ASSETS_MISSING — Firecracker assets missing

The firecracker binary, guest kernel or worker rootfs is missing from DATANIVRA_AGENT_ISOLATION_FIRECRACKER_DIR.

What to do: Build the rootfs with tools/isolation/build_firecracker_rootfs.sh and place firecracker and vmlinux next to it.

ISOLATION_FIRECRACKER_JAILER_UNAVAILABLE — Firecracker jailer launcher not ready

The agent is set up to run Firecracker under the jailer, but the root-owned launcher did not answer, refused the request, or names different Firecracker files than the agent.

What to do: Run sudo -n /usr/local/libexec/datanivra-firecracker-launch check on the agent host and fix what it reports (see the isolated execution documentation, Firecracker with the jailer); restart the agent after its user joined the VMM user's group.

ISOLATION_FIRECRACKER_TOOLS_MISSING — Firecracker host tools missing

The Firecracker backend needs mkfs.ext4 and debugfs (e2fsprogs) on the agent host to prepare and read stage drives.

What to do: Install e2fsprogs on the agent host.

ISOLATION_IMAGE_NOT_CONFIGURED — Worker image not configured

An isolation backend is selected but DATANIVRA_AGENT_ISOLATION_IMAGE is not set.

What to do: Set DATANIVRA_AGENT_ISOLATION_IMAGE to this agent's image digest (name@sha256:...).

ISOLATION_IMAGE_NOT_PINNED — Worker image not digest-pinned

The worker image is a mutable tag. Isolated workers only run content-addressed images.

What to do: Use name@sha256:<digest> (or a local sha256:<image id>).

ISOLATION_IMAGE_SIGNATURE_UNVERIFIED — Worker image signature not verified

Signature verification is required but cosign could not verify the image for the configured identity and issuer (or cosign is missing).

What to do: Install cosign, set DATANIVRA_AGENT_ISOLATION_COSIGN_IDENTITY and _ISSUER, and use the signed release digest.

ISOLATION_IMAGE_UNAVAILABLE — Worker image not present

The pinned worker image is not available to the runtime and could not be pulled.

What to do: Pull the image on the agent host (docker pull name@sha256:...) and retry.

ISOLATION_KERNEL_BOUNDARY_NOT_OBSERVED — No kernel boundary observed

The gVisor backend is selected but the worker sees the host kernel, so the runtime is not actually gVisor.

What to do: Check the runsc runtime registration (docker info) and DATANIVRA_AGENT_ISOLATION_OCI_RUNTIME.

ISOLATION_KVM_UNAVAILABLE — KVM unavailable

The Firecracker backend needs read-write access to /dev/kvm.

What to do: Run the agent on a Linux host with KVM and add the agent user to the kvm group.

ISOLATION_MOUNT_PATH_UNSUPPORTED — Path cannot be mounted

A workspace, source or target path contains characters the runtime's mount syntax cannot carry safely (comma, newline) or is relative.

What to do: Use absolute paths without commas for the workspace, sources and directory targets.

ISOLATION_NETWORK_CONFLICT — Stage needs two networks

One stage would need both the source and the target network.

What to do: Contact support with the job id; this indicates an unexpected job shape.

ISOLATION_NETWORK_NOT_CONFIGURED — Worker network not configured

A stage reads a network source or writes a network target, but no worker network is configured, so it is refused (workers have no network by default).

What to do: Create a container network that reaches only the source/target systems and set DATANIVRA_AGENT_ISOLATION_SOURCE_NETWORK / _TARGET_NETWORK.

ISOLATION_OCI_RUNTIME_MISSING — OCI runtime not registered

The configured OCI runtime (runc, or runsc for gVisor) is not registered with the container runtime.

What to do: For gVisor install runsc and register it as a Docker runtime; see docs/runbooks/isolated-execution.md.

ISOLATION_POLICY_CONFLICT — Isolation requirements contradict each other

The tenant's backend allow-list and the agent's local floor leave no permitted backend.

What to do: Align the tenant's allowed isolation backends with the agent's DATANIVRA_AGENT_ISOLATION_MINIMUM_LEVEL.

ISOLATION_RECONCILE_FAILED — Earlier isolated workers could not be confirmed stopped

The agent could not list or stop the isolated workers it started earlier (for example after a restart), so it refuses new isolated stages and keeps their workspaces until it can.

What to do: Check that the container runtime (or the Firecracker host) responds, then run `datanivra-agent isolation stop-workers --yes`; the agent retries on every maintenance sweep. A Firecracker recovery record that cannot be read stays until an operator has checked that no microVM of that run is running and removed the file from the agent's state directory (isolation-firecracker/).

ISOLATION_REQUIREMENT_UNSATISFIED — Required isolation not met

The job requires an isolation level or backend (tenant policy or the agent's local floor) that this agent's isolation backend does not provide. The job was refused before any source was opened.

What to do: Run the job on an agent configured with a satisfying backend (DATANIVRA_AGENT_ISOLATION_BACKEND), or have a tenant admin review the isolation policy. The agent never falls back to weaker isolation.

ISOLATION_RUNTIME_START_FAILED — Isolated worker could not start

The container runtime refused to start the worker (for example a missing network or an invalid mount).

What to do: Run `datanivra-agent isolation doctor`; check the configured networks and that the workspace is on a local filesystem.

ISOLATION_RUNTIME_UNAVAILABLE — Isolation runtime unavailable

The configured container runtime (Docker or Podman) is not reachable by the agent supervisor.

What to do: Check that the runtime is installed and running and that the agent user may use it; run `datanivra-agent isolation doctor`.

ISOLATION_SELF_CHECK_FAILED — Worker self-check failed

A worker started under the full hardening did not answer its self-check.

What to do: Run `datanivra-agent isolation doctor` and check that the image is this agent's image and supports --read-only and --user.

ISOLATION_SOURCE_LOCAL_PATH_UNSUPPORTED — Connection names an unmounted directory

A connection document references a local directory other than its declared root; workers only see what is mounted explicitly.

What to do: Reference files (CA bundles, key files) by file path, or move the data under the connection's root.

ISOLATION_SOURCE_UNSUPPORTED — Source cannot be opened in a worker

The source's connection cannot be delivered to an isolated worker (for example a relative SQLite path).

What to do: Use an absolute path for file-based sources, or a network connection with a worker network.

ISOLATION_STAGE_NOT_ISOLATED — Work type not isolated by this agent

An isolation requirement applies, but this work type (for example a compliance-guard scan) still runs inside the agent process, so it is refused instead of running unisolated.

What to do: Run the scan on an agent with the Standard backend and without an isolation requirement, or wait for an agent release that isolates it (see the isolated execution documentation, Plan for).

ISOLATION_SUPERVISOR_IS_ROOT — Agent runs as root

Isolated workers run with the supervisor's UID; running the agent as root would make them root.

What to do: Run the agent as an unprivileged user (the packaged images use uid 10001).

JOB_AUTHORIZATION_* — Job authorization rejected

The job's signed authorization did not verify: signed with a key this agent does not trust (UNKNOWN_KEY), altered (INVALID), expired or not yet valid (EXPIRED / NOT_YET_VALID), issued for another job, agent or lease (MISMATCH) or not covering a requested industry pack (PACK_NOT_PERMITTED). Nothing was read.

What to do: Check the host clock (NTP) for EXPIRED / NOT_YET_VALID and upgrade the agent to the current release for UNKNOWN_KEY; otherwise contact support with the job id and the code.

Operator runbook: docs/runbooks/job-authorization-keys.md

JOB_AUTHORIZATION_MISSING — Job authorization missing

The agent received an engine job without the signed job authorization DataNivra issues for every job. The agent refuses such jobs before reading any data.

What to do: Make sure the agent connects to the DataNivra control plane it was enrolled with. If the control plane is correct, contact support with the job id.

Operator runbook: docs/runbooks/job-authorization-keys.md

JOB_CANCELLED — Job cancelled

The job stopped early (cancelled by a user, revocation or lease expiry). Nothing was published.

What to do: Re-submit the request if the cancellation was not intended.

JOB_FAILED — Job failed

A job step failed without a more specific code.

What to do: Check the failed step in the console and the agent logs; retry the request.

KEY_VERSION_NOT_FOUND — Key version not found

The masking policy references a pseudonymization key version that is not in the keyset.

What to do: Add the key version to the keyset, or update the policy to a key version you hold.

Operator runbook: docs/runbooks/bad-key-version.md

KEYSET_INVALID — Pseudonymization keyset invalid

The pseudonymization keyset secret is malformed.

What to do: Fix the keyset secret in your secret store (it needs a primary version and base64url keys).

Operator runbook: docs/runbooks/bad-key-version.md

LEASE_EXPIRED — Lease expired

The agent's lease on a job ran out before it finished; the job stops without publishing.

What to do: Check agent health and heartbeats; long jobs may need a less loaded agent. The job can be retried.

Operator runbook: docs/runbooks/agent-offline.md

MANIFEST_CHECKSUM_REQUIRED — Manifest checksum required

Provisioning needs the manifest checksum the control plane recorded, and none was supplied.

What to do: Provision a version that completed certification and was accepted by the control plane.

Operator runbook: docs/runbooks/corrupt-manifest.md

MASKING_DOMAIN_KEY_* — Masking domain keys mixed

MASKING_DOMAIN_KEY_MIXED: two columns of the same masking domain would be masked with different keys or key versions in one job. The same identity would get two pseudonyms and linked systems would stop joining (a half-done key rotation).

What to do: Rotate a domain by changing the key version (or the domain version) on every rule of that domain at once, then rebuild.

MASKING_PARAMETER_INVALID — Masking rule parameter invalid

A masking rule parameter has the wrong type or an unknown name (for example a TEXT_SPAN_MASK MIN_CONFIDENCE outside 0..1 or an unknown ENTITY_<TYPE>).

What to do: Correct the parameter in a new masking policy version.

MASKING_POLICY_REQUIRED — Masking policy required

The source holds sensitive or production data, so an approved masking policy is required.

What to do: Attach an approved masking policy to the request.

Operator runbook: docs/runbooks/expired-policy.md

MINIMUM_VERSION_UNKNOWN — Minimum agent version unknown

The control plane has not announced a minimum agent version to this agent yet (it arrives with a heartbeat acknowledgement).

What to do: Nothing to do; run the doctor again after the agent has sent a heartbeat.

Operator runbook: docs/runbooks/agent-doctor.md

MODEL_ADAPTER_NOT_AVAILABLE — No model adapter installed

Even with an approved model-provider policy, the agent ships no model client: every model call is refused after the gate check.

What to do: None. Model adapters are an owner-approved roadmap item.

MODEL_EGRESS_* — Model call refused by the egress gate

The agent's model egress gate denied a model call (the default): MODEL_EGRESS_NO_POLICY (no approved model-provider policy), MODEL_EGRESS_POLICY_MODE (NONE or LOCAL_ONLY), MODEL_EGRESS_POLICY_NOT_APPROVED, MODEL_EGRESS_SOD_VIOLATION (the requester approved it), MODEL_EGRESS_POLICY_EXPIRED, MODEL_EGRESS_PURPOSE_NOT_ALLOWED, MODEL_EGRESS_SCHEME (not https), MODEL_EGRESS_ENDPOINT_INVALID or MODEL_EGRESS_ENDPOINT_NOT_ALLOWED. MODEL_EGRESS_ALLOWED is the audit code of an allowed decision. No content left the agent.

What to do: Nothing to do unless your organization decided to use an external model; then a tenant administrator approves an APPROVED_EXTERNAL model-provider policy (datanivra model-policy).

MODEL_POLICY_NOT_APPROVED — Model-provider policy not approved

A dataset command delivered a model-provider policy version that is not APPROVED; the agent refused the command.

What to do: Approve the model-provider policy version (tenant administrator) or revoke it, then retry.

NOTHING_TO_BUILD — Nothing to build

The dataset job produced no candidate data.

What to do: Check the subset definition and filters; they may select no rows.

POLICY_CHECKSUM_MISMATCH — Policy checksum mismatch

The policy content received does not match its recorded checksum.

What to do: Re-submit the request; if it repeats, contact support with the job id.

Operator runbook: docs/runbooks/expired-policy.md

POLICY_KIND_MISMATCH — Wrong policy kind

A command referenced a policy of the wrong kind (for example value-assisted matching without an identity-graph policy).

What to do: Request the work again from the console; do not hand-craft commands.

POLICY_NOT_APPROVED — Policy not approved

The referenced policy version is not approved.

What to do: Approve the policy version (respecting separation of duties) or reference an approved one.

Operator runbook: docs/runbooks/expired-policy.md

POLICY_REVOKED — Policy revoked

The referenced policy version was revoked; running jobs using it are stopped.

What to do: Reference a current approved policy version and re-submit.

Operator runbook: docs/runbooks/expired-policy.md

PROTOCOL_ERROR — Protocol error

The control plane's answer was malformed or too large.

What to do: Make sure the agent and control plane versions are compatible; check that no proxy rewrites responses.

Operator runbook: docs/runbooks/control-plane-unavailable.md

PROTOCOL_UNSUPPORTED — Protocol version unsupported

The protocol version recorded at enrollment is not supported by this agent build.

What to do: Upgrade or reinstall the agent from a current release and enroll it again with a new token.

Operator runbook: docs/runbooks/agent-doctor.md

PROXY_IN_USE — HTTPS proxy in use

An HTTPS proxy is configured, so direct TCP and TLS probes are skipped; the health check goes through the proxy.

What to do: Nothing to do; judge connectivity by the CONTROL_PLANE_HEALTH result.

Operator runbook: docs/runbooks/agent-doctor.md

PSEUDONYMIZATION_KEY_TOO_SHORT — Pseudonymization key too short

A pseudonymization key is shorter than 32 bytes.

What to do: Generate a key of at least 32 random bytes in your secret store.

Operator runbook: docs/runbooks/bad-key-version.md

PSEUDONYMIZATION_KEY_UNAVAILABLE — Pseudonymization key unavailable

The pseudonymization key could not be loaded.

What to do: Check the key reference and the agent's access to your secret store.

Operator runbook: docs/runbooks/missing-secret.md

PUBLICATION_NOT_AUTHORIZED — Publication not authorized

The control plane refused to let the agent publish the finished dataset (for example the request was cancelled, the dataset was revoked or the job's lease ended while it ran). Nothing was published or provisioned.

What to do: Check the request's status in the console. If it should still run, submit it again.

PUBLISH_INVALID_DOCUMENT — Invalid evidence document

An evidence document name is not a flat file name.

What to do: Retry; if it repeats, contact support with the job id.

Operator runbook: docs/runbooks/partial-evidence-upload.md

PUBLISH_VERIFICATION_FAILED — Publish verification failed

A copied dataset table does not match its checksum.

What to do: Check disk health and free space on the datasets volume, then request a new version.

Operator runbook: docs/runbooks/corrupt-manifest.md

RAG_EVAL_SIZE_INVALID — Eval-set size invalid

The requested number of answerable or adversarial cases is negative or exceeds the corpus.

What to do: Lower --answerable or raise --per-kind.

RATE_LIMITED — Rate limited

The control plane rate-limited the agent. Reports are retried from the outbox.

What to do: No action normally needed; reduce concurrency if it persists.

READ_ONLY_ATTESTED — Read-only access attested

Read-only access cannot be proven for this connector kind (for example object storage), so the agent relies on the operator's read_only_attested flag.

What to do: Make sure the credential really is read-only (see the connector's integration page).

Operator runbook: docs/runbooks/agent-doctor.md

READ_ONLY_UNVERIFIED — Read-only access not proven

The source credential could not be proven read-only and was not attested, so the job refused to read it (fail closed).

What to do: For object stores or non-PostgreSQL SQL dialects, apply least-privilege grants and set read_only_attested in the connection secret.

Operator runbook: docs/runbooks/source-unavailable.md

REPORT_NOT_ACCEPTED — Report not accepted

The control plane refused a report from the agent without naming a more specific reason (for example a report for a job that is no longer active). The job stops; nothing is published.

What to do: Check that the agent and the control plane are on supported versions (`datanivra-agent check`), then retry the request. If it repeats, contact support with the job id.

Operator runbook: docs/runbooks/agent-doctor.md

REPRO_* — Reproduction refused

A production-issue reproduction failed closed: REPRO_CLOSURE_UNBOUNDED (max_selected_rows and max_fan_out must both be set), REPRO_UNKNOWN_SEEDS (a seed key matched no root row), REPRO_NO_ROOTS (nothing selected), REPRO_STRATEGY_UNSUPPORTED / REPRO_PREDICATES_REFUSED / REPRO_INTEGRITY_REQUIRED (only SEED_ENTITY or DATE_WINDOW roots, no business-rule literals, intact integrity), REPRO_OVERRIDE_REFUSED (a masking rule carries ALLOW_SENSITIVE_PASS_THROUGH or ALLOW_WEAK_STRATEGY) or REPRO_FREE_TEXT_UNHANDLED (a binary or nested key column cannot be masked safely). Nothing was published and seed values were not reported.

What to do: Fix the subset bounds, the seed list (customer-side) or the masking policy as the code says, then request the reproduction again.

REPRO_ENGINE_UNSUPPORTED — Engine cannot build reproductions

The agent's configured engine does not apply the reproduction rules (bounded closure, unknown-seed refusal, free-text redaction), so the reproduction was refused.

What to do: Use the default engine adapter (datanivra_agent.engine_adapter:create_engine) or an engine that declares supports_repro.

REPRO_LOCAL_BACKEND_REQUIRED — Reproduction needs the local backend

Reproductions use seed lists and closure bounds, which the Spark subset backend does not support, so the job was refused before any row was read.

What to do: Run reproductions on an agent with DATANIVRA_AGENT_ENGINE_EXECUTION_BACKEND=local.

REPRO_SUBSET_REQUIRED — Reproduction needs a subset

A production-issue reproduction was requested without a subset definition, so there was nothing to bound the dataset to the affected entities. Nothing was read.

What to do: Add a SEED_ENTITY (seed-list handle) or DATE_WINDOW subset with max_selected_rows and max_fan_out to the request.

RUNNING_AS_ROOT — Agent runs as root

The agent process runs as root. The official image runs as an unprivileged user (uid 10001).

What to do: Run the agent as an unprivileged user (do not override the image's USER).

Operator runbook: docs/runbooks/agent-doctor.md

SCENARIO_KIND_MISMATCH — Scenario kind mismatch

A synthetic scenario's kind does not match its template.

What to do: Pick a scenario template of the right kind for the request.

SCENARIO_KIND_UNSUPPORTED — Scenario kind not available

No core scenario template exists for the requested scenario kind, so the agent cannot generate it from a custom schema.

What to do: Choose another scenario kind (for example NORMAL or BOUNDARY).

Operator runbook: docs/runbooks/test-data-api.md

SECRET_ACCESS_DENIED — Secret access denied

The secret store refused the agent's identity access to the referenced secret.

What to do: Grant the agent's identity read access to that secret in your secret store.

Operator runbook: docs/runbooks/agent-doctor.md

SECRET_BACKEND_UNAVAILABLE — Secret store unavailable

The remote secret store (Key Vault, Secrets Manager or Vault) could not be reached or failed.

What to do: Check the agent's network access and identity for the secret store, then retry.

Operator runbook: docs/runbooks/agent-doctor.md

SECRET_FIELD_MISSING — Secret field missing

The secret reference points at a JSON field that is missing or not a string.

What to do: Fix the #field part of the reference or add the field to the secret.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_FILE_PERMISSIONS — Secret file too open

A file:// secret is readable by group or other users.

What to do: Run `chmod 600` on the secret file.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_NOT_FOUND — Secret not found

The secret store (or environment variable) returned no value for the reference.

What to do: Create the secret, or fix the reference, then retry.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_NOT_JSON_OBJECT — Secret is not a JSON object

A connection secret must be a JSON document, or a #field was used on a non-JSON secret.

What to do: Store the connection document as JSON, or drop the #field from the reference.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_PROVIDER_NOT_CONFIGURED — Secret provider not configured

No secret provider is configured for the reference's scheme (for example a vault scheme without its plugin).

What to do: Configure the matching secret provider plugin or use a supported scheme (env://, file://, k8s).

Operator runbook: docs/runbooks/missing-secret.md

SECRET_PROVIDER_PLUGIN_INVALID — Secret provider plugin invalid

A configured secret provider plugin failed to load or is not a secret provider.

What to do: Fix DATANIVRA_AGENT_SECRET_PROVIDER_PLUGINS or the plugin package.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_REF_INVALID — Secret reference invalid

The secret reference is malformed or uses an unsupported scheme.

What to do: Correct the reference format (for example env://NAME or file://path#field).

Operator runbook: docs/runbooks/missing-secret.md

SECRET_REF_NOT_ALLOWED — Secret reference not allowed

The reference is outside the patterns or prefixes the agent allows for jobs.

What to do: Use a reference that matches the agent's allowed patterns, or widen them deliberately in the agent configuration.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_REF_OUTSIDE_ALLOWLIST — Secret reference not allowed

The reference matches none of the operator's allowed patterns (DATANIVRA_AGENT_SOURCE_REF_PATTERNS / TARGET_REF_PATTERNS / KEY_REF_PATTERNS), so jobs may not use it.

What to do: Use an allowed reference or extend the pattern list on the agent.

Operator runbook: docs/runbooks/agent-doctor.md

SECRET_TOO_LARGE — Secret too large

A secret file exceeds the 64 KiB limit.

What to do: Store only the connection document in the secret.

Operator runbook: docs/runbooks/missing-secret.md

SECRET_UNRESOLVABLE — Secret unresolvable

A secret reference could not be resolved inside your environment.

What to do: Check the reference and the agent's access to the secret store. Secret values never leave your environment.

Operator runbook: docs/runbooks/missing-secret.md

SEED_LIST_* — Seed list could not be used

The subset's seed_list_ref could not be resolved inside the agent: SEED_LIST_RESOLVER_MISSING (no DATANIVRA_AGENT_ENGINE_SEED_LIST_DIR configured), SEED_LIST_HANDLE_INVALID / SEED_LIST_HANDLE_REQUIRED (use a seedlist:// handle), SEED_LIST_NOT_FOUND (no such file inside the directory), SEED_LIST_SCHEME_UNSUPPORTED, SEED_LIST_INVALID or SEED_LIST_TOO_LARGE.

What to do: Place the list in the agent's seed-list directory and reference it as seedlist:// followed by the file name; see the agent's seed-list documentation.

SNAPSHOT_CORRUPTED — Snapshot corrupted

A snapshot object is missing or does not match its hash, so the rewind was refused. The target was not changed.

What to do: Take a new snapshot of a freshly provisioned version; delete the damaged snapshot.

SNAPSHOT_NOT_FOUND — Snapshot not found

No snapshot with this id exists for the target.

What to do: List snapshots with datanivra-agent snapshots --target-path PATH and use one of those ids.

SNAPSHOT_NOT_SUPPORTED — Snapshots not supported for this target

Snapshot and rewind are available for DIRECTORY targets only; other target kinds are designed but not implemented.

What to do: Re-provision the certified version instead of rewinding.

SNAPSHOT_UNSAFE_ENTRY — Unsafe entry in provisioned directory

The provisioned directory contains a symbolic link, which snapshots never follow.

What to do: Remove the link from the provisioned directory, then take the snapshot again.

SOURCE_CHECK_FAILED — Source check failed

Opening the source or running its read-only proof failed with an unclassified error (details are not shown because driver messages can contain host names or values).

What to do: Check the source network access and the connection document locally, then run the doctor again.

Operator runbook: docs/runbooks/agent-doctor.md

SOURCE_NOT_READ_ONLY — Source credential can write

The read-only proof found write privileges on the source credential, so the job refused to read (fail closed).

What to do: Use a credential with read-only grants (see the connector's integration page) and retry.

Operator runbook: docs/runbooks/source-unavailable.md

SOURCE_TYPE_UNSUPPORTED — Source column type unsupported

A source column could not be converted to the engine's columnar format.

What to do: Exclude the column or cast it in a view, then re-run discovery.

Operator runbook: docs/runbooks/schema-drift.md

STAGE_METADATA_INVALID — Stage metadata invalid

Engine stage metadata is missing, unreadable or does not describe a stage table.

What to do: Retry the job; if it repeats, contact support with the job id.

Operator runbook: docs/runbooks/masking-crash.md

STAGE_PURGE_FAILED — Unmasked stage not deleted

The agent could not delete the unmasked subset files of a job's sandbox, so the job stopped instead of continuing with raw rows on disk. The sandbox stays tracked and the periodic sweep retries the deletion.

What to do: Check the agent's workspace volume (permissions, read-only mount, disk errors); the sweep deletes the files once the volume is writable.

STORAGE_DIR_MISSING — Agent directory missing

A state, workspace or datasets directory does not exist yet; the agent creates it with mode 0700 when it starts.

What to do: Nothing to do if the parent is on a persistent volume; otherwise mount the volume first.

Operator runbook: docs/runbooks/agent-doctor.md

STORAGE_LOW_FREE_SPACE — Low free space

The workspace volume has less free space than DATANIVRA_AGENT_WORKSPACE_QUOTA_BYTES.

What to do: Enlarge the workspace volume or lower the quota to what the volume can hold.

Operator runbook: docs/runbooks/agent-doctor.md

STORAGE_NOT_WRITABLE — Agent directory not writable

A state, workspace or datasets directory cannot be created or written by the agent user.

What to do: Mount the volume writable for the agent user (uid 10001 in the image).

Operator runbook: docs/runbooks/agent-doctor.md

STORAGE_OWNER_MISMATCH — Agent directory owned by another user

A state, workspace or datasets directory is owned by a different user than the agent, so its permissions cannot be enforced.

What to do: Change the owner of the directory to the agent user (for example with fsGroup / chown).

Operator runbook: docs/runbooks/agent-doctor.md

STORAGE_PERMISSIONS_TOO_OPEN — Agent directory too open

A state, workspace or datasets directory is accessible to group or other users; the agent resets it to 0700 at start.

What to do: Nothing to do if the agent can chmod it; otherwise fix the volume's permissions.

Operator runbook: docs/runbooks/agent-doctor.md

STRATEGY_NOT_SUPPORTED_DISTRIBUTED — Strategy needs the local backend

Edge-case rules and seed lists are not supported by distributed execution.

What to do: Run the job on the local backend or remove those rules.

SUBSET_MEMORY_BUDGET_EXCEEDED — Subset memory budget exceeded

The projected subset exceeds the agent's memory budget.

What to do: Narrow the subset (smaller root selection or fewer tables) or give the agent more memory.

SYNTHETIC_SCHEMA_REQUIRED — Synthetic schema required

A synthetic-only dataset reads no source, so its tables come from an industry pack; none was named or activated.

What to do: Name an industry pack (pack_id) in the dataset request or test-data profile, and enable that pack for your organization.

TARGET_BUSY — Target busy

Another delivery, cleanup or rewind of the same dataset version on this target held the target lock for more than 5 minutes, so the agent stopped waiting instead of racing it.

What to do: Nothing to do in most cases: the control plane retries the job. If it keeps happening, check for a stuck agent process on the target host.

Operator runbook: docs/runbooks/target-unavailable.md

TARGET_CONFIG_INVALID — Target configuration invalid

The target environment's connection settings are invalid.

What to do: Fix the target connection document (for example use an absolute directory path).

Operator runbook: docs/runbooks/target-unavailable.md

TARGET_CREATE_PRIVILEGE_MISSING — Target lacks CREATE privilege

The target database credential has no CREATE privilege on the target schema (or on the database to create the schema). Checked read-only; nothing was written.

What to do: Grant CREATE on the target schema (or database) to the loader role.

Operator runbook: docs/runbooks/agent-doctor.md

TARGET_DELETE_INCOMPLETE — Target deletion incomplete

A revoked dataset version was withdrawn from the target directory, but some of its files could not be deleted yet, so the revocation is reported incomplete and retried.

What to do: Check the target directory's permissions and disk; the retried revocation deletes the remaining files.

TARGET_INVENTORY_FAILED — Target inventory failed

The agent could not list which dataset versions are present in a target (the directory could not be read, or the ownership table could not be queried). Nothing was changed in the target.

What to do: Check that the agent's target credential can read the target schema's _datanivra_provisioning table, or that the agent user can list the target directory.

Operator runbook: docs/runbooks/ephemeral-postgres-target.md

TARGET_INVENTORY_UNSUPPORTED — Target inventory not supported

The target's provider does not implement listing which dataset versions are present, so orphaned copies in it cannot be detected automatically.

What to do: Track and remove copies in this target through teardown jobs; prefer a target kind whose provider supports inventory.

Operator runbook: docs/runbooks/ephemeral-postgres-target.md

TARGET_NOT_READY — Target not ready

The target environment could not be reached or is not writable, so provisioning did not start. The certified dataset is kept and can be provisioned once the target is back.

What to do: Check the target environment's connection document and network access, then provision again.

TARGET_NOT_WRITABLE — Target directory not writable

A DIRECTORY target path does not exist or is not writable by the agent user.

What to do: Create the directory on a writable volume owned by the agent user.

Operator runbook: docs/runbooks/agent-doctor.md

TARGET_PROVIDER_UNSUPPORTED — Target kind not supported

The target document names a kind for which this agent has no target provider, so the agent refused to read or write the target instead of guessing how to handle it.

What to do: Use a supported target kind (DIRECTORY or POSTGRESQL) in the target document, or upgrade the agent to a release that ships a provider for that kind.

Operator runbook: docs/runbooks/ephemeral-postgres-target.md

TARGET_TABLE_CONFLICT — Target table conflict

A target table belongs to another dataset or is not managed by DataNivra, so it is not overwritten.

What to do: Use a different target schema, or drop the unmanaged table yourself if it is safe.

Operator runbook: docs/runbooks/target-unavailable.md

TARGET_TABLE_NAME_COLLISION — Target table name collision

Two dataset tables map to the same target table name.

What to do: Rename tables in the target mapping.

Operator runbook: docs/runbooks/target-unavailable.md

TARGET_UNAVAILABLE — Target unavailable

The target environment could not be reached or provisioned.

What to do: Check network access and credentials from the agent to the target, then retry.

Operator runbook: docs/runbooks/target-unavailable.md

TARGET_VERSION_NOT_PROVISIONED — Version not provisioned in target

The dataset version is not present in this target, so there is nothing to snapshot.

What to do: Provision the certified version first.

TARGET_WRITE_FAILED — Target write failed

The target database rejected the load.

What to do: Check the target credential's write grants and free space, then retry.

Operator runbook: docs/runbooks/target-unavailable.md

TENANT_MISMATCH — Tenant mismatch

A command or finding addressed another tenant; the agent refused it.

What to do: Contact support with the job id; this indicates a configuration or routing error.

Operator runbook: docs/runbooks/tenant-authorization-failure.md

TEXT_SPAN_RULE_MISSING — TEXT_SPAN_MASK rule required

A document-set build ran without a TEXT_SPAN_MASK rule in its masking policy.

What to do: Add a TEXT_SPAN_MASK rule to the masking policy.

TEXT_SPAN_RULE_REQUIRED — Not a TEXT_SPAN_MASK rule

In-text masking was configured with a rule whose strategy is not TEXT_SPAN_MASK.

What to do: Use a TEXT_SPAN_MASK rule for free-text columns.

TEXT_SPAN_STRATEGY_UNSUPPORTED — Entity strategy not allowed in text

An ENTITY_<TYPE> override of a TEXT_SPAN_MASK rule named a strategy that cannot replace a span inside text (PASS_THROUGH, NULLIFY, NUMERIC_PERTURB, CUSTOM_PLUGIN or TEXT_SPAN_MASK).

What to do: Choose a replacing strategy such as REDACT, NAME_REPLACE, EMAIL_REPLACE or FORMAT_PRESERVING_SYNTHETIC.

TEXT_TOO_LARGE — Text value too large

A text value exceeded the TEXT_SPAN_MASK rule's MAX_TEXT_CHARS limit; it was not masked and the job failed closed.

What to do: Raise MAX_TEXT_CHARS within reason or split the documents into smaller parts.

TLS_CERT_EXPIRING — Control-plane certificate expiring

The control plane's TLS certificate expires within 14 days.

What to do: Nothing to do on the agent; certificates are renewed by the operator. Contact support if it does not change.

Operator runbook: docs/runbooks/agent-doctor.md

TLS_CERT_INVALID — Control-plane certificate not trusted

The control plane's certificate failed verification (untrusted issuer, wrong host name or expired). A TLS-inspecting proxy is the usual cause.

What to do: Set DATANIVRA_AGENT_CA_BUNDLE to your proxy's CA bundle, or allow the host through without inspection.

Operator runbook: docs/runbooks/agent-doctor.md

TLS_HANDSHAKE_FAILED — TLS handshake failed

The TLS handshake with the control plane did not complete (connection reset or protocol mismatch).

What to do: Check firewalls and proxies between the agent and the control plane.

Operator runbook: docs/runbooks/agent-doctor.md

UNAUTHORIZED — Agent not authorized (HTTP 401)

The control plane did not accept the agent's token. The next token exchange usually repairs it; reports are retried.

What to do: If it persists, check clock synchronisation on the agent host and that the agent is not revoked.

Operator runbook: docs/runbooks/agent-offline.md

UNSTRUCTURED_RESIDUAL_PII — Residual personal data after in-text masking

Workbook 09: after TEXT_SPAN_MASK replaced the detected spans, the residual re-scan still found a detection outside the inserted surrogates. The batch was never emitted and nothing was published. Only counts and codes were reported.

What to do: Lower MIN_CONFIDENCE or adjust ENTITY_<TYPE> overrides on the TEXT_SPAN_MASK rule, then rebuild. Detection is rule-based and can miss values; see the unstructured test data limitations.

VALUE_ASSISTED_MATCHING_DISABLED — Value-assisted matching not enabled

The identity-graph version did not opt in to value-assisted matching, so no value was read.

What to do: Enable value_assisted_matching in an identity-graph version and have it approved.

WORKSPACE_CLEANUP_FAILED — Agent workspace cleanup failed

The agent could not remove or quarantine old content in its local workspace, so it refused to reuse that workspace rather than mix stale files into a new job.

What to do: Check the agent's state directory permissions and free space; the agent retries quarantined deletions on every sweep.

Operator runbook: docs/runbooks/agent-doctor.md

WORKSPACE_QUOTA_EXCEEDED — Workspace quota exceeded

The job sandbox exceeded its disk quota (bytes, or the number of files and directories), or part of it could not be measured.

What to do: Increase DATANIVRA_AGENT_WORKSPACE_QUOTA_BYTES or DATANIVRA_AGENT_WORKSPACE_QUOTA_ENTRIES, or narrow the subset.

Connector codes

Connector codes appear when validating or discovering a source. Which connectors ship today is listed on the integrations page.

API_BUDGET_EXHAUSTED — SaaS API budget too low

The application reports fewer remaining API calls than the connection document's floor (min_api_budget), so the connector stopped before using up the budget other integrations need.

What to do: Wait for the daily budget to reset, raise the org's API limit, or lower min_api_budget deliberately.

COLUMN_NOT_FOUND — Column not found

A read asked for a column the table does not have (or the copybook does not define).

What to do: Rediscover the source so the dataset request uses current column names.

CONNECTION_CONFIG_INVALID — Connection document invalid

The resolved connection document failed validation (unknown field, wrong type, or a credential given as plain text where a secret reference is required).

What to do: Fix the connection secret's JSON; give credentials as <field>_ref secret references.

Operator runbook: docs/runbooks/source-unavailable.md

CONNECTOR_ALREADY_REGISTERED — Connector already registered

A plugin tried to register a connector kind that already has one. Built-ins cannot be replaced.

What to do: Remove the conflicting plugin from your custom agent image.

CONNECTOR_DRIVER_INCOMPLETE — Vendor driver incomplete

The vendor driver installed in this agent image lacks files it needs to connect. For IBM Db2, IBM's CLI driver cannot open any connection without IBM GSKit (its lib/icc folder).

What to do: Build the agent extension image for IBM Db2 (/docs/agent-extension-images): IBM's pinned ibm_db wheel carries the complete driver. Do not remove files from it.

CONNECTOR_KIND_UNKNOWN — Unknown connector kind

The connection document names a connector kind that does not exist.

What to do: Use one of the kinds listed on the integrations page.

CONNECTOR_NOT_AVAILABLE — Connector not available

The kind is a designed extension point without a shipped connector (for example Oracle or Snowflake today).

What to do: Use an available connector (for example export to Parquet and read it with Local files, S3 or Azure), or install a connector plugin.

CONNECTOR_PLATFORM_UNSUPPORTED — Connector not available on this processor architecture

The source system's vendor publishes no driver for the machine architecture the agent runs on (for example IBM publishes no Linux arm64 Db2 driver), so the agent image cannot include it.

What to do: Run the agent on an architecture the message names (for the IBM Db2 preview: x86_64, that is linux/amd64).

CONNECTOR_READ_BOUNDS_INVALID — Invalid read bounds

A bounded read was requested with a batch size below 1 or a negative row limit.

What to do: Contact support with the job id; the request was built incorrectly.

CONNECTOR_READ_CANCELLED — Read cancelled

The job was cancelled while the connector was streaming rows; the read stopped within one batch.

What to do: No action needed; start the job again if the cancellation was unintended.

CONNECTOR_WRITE_BLOCKED — Write statement blocked

The connector's statement guard blocked a statement that is not a read. The statement text is never logged.

What to do: Nothing to fix on the source; report it to support with the job id if you did not expect it.

COPYBOOK_FLOAT_UNSUPPORTED — Floating-point copybook field

The copybook uses COMP-1 or COMP-2 floating-point items, which the mainframe connector does not decode yet.

What to do: Convert those fields in the unload job (for example to packed decimal), or convert the extract to Parquet and use the Local files connector.

COPYBOOK_LEVEL_UNSUPPORTED — Unsupported copybook level

The copybook uses level 66 or 77 items, or a level outside 01-49.

What to do: Provide a copybook with one 01 record and levels 02-49 (88 condition names are ignored).

COPYBOOK_NAME_INVALID — Invalid copybook field name

A flattened field name is not identifier-shaped or is not unique.

What to do: Rename the field in the copybook copy you give the agent; names become column names.

COPYBOOK_ODO_UNSUPPORTED — OCCURS DEPENDING ON

The copybook uses OCCURS DEPENDING ON, which the preview connector refuses rather than guesses.

What to do: Unload a fixed-size layout, or convert the extract with your own tooling and use the Local files connector.

COPYBOOK_PICTURE_UNSUPPORTED — Unsupported PICTURE clause

A PIC clause uses symbols other than A, X, 9, S and V, mixes alphanumeric and numeric symbols, or has more than 38 digits.

What to do: Simplify the picture in the copybook the agent reads, or convert the extract first.

COPYBOOK_REDEFINES_UNSUPPORTED — REDEFINES

The copybook uses REDEFINES, which the preview connector refuses rather than guessing which layout applies.

What to do: Split record types into separate unloads with one layout each, or convert the extract first.

COPYBOOK_SYNTAX — Copybook syntax

The copybook could not be parsed: every statement must start with a level number, there must be exactly one 01 record, and elementary items need a PICTURE.

What to do: Check the copybook file named in the source's table declaration.

COPYBOOK_USAGE_UNSUPPORTED — Unsupported USAGE

An alphanumeric item declares a computational USAGE.

What to do: Correct the copybook: text fields must be DISPLAY.

CSV_COLUMN_COUNT_MISMATCH — CSV column count mismatch

The declared column_names do not match the file's width.

What to do: Correct column_names in the connection document.

CSV_HEADER_UNDECLARED — CSV header not declared

A CSV file set must declare has_header; the connector will not guess.

What to do: Set has_header (true or false) in the connection document.

CSV_HEADER_UNTRUSTED — CSV header not identifier-shaped

The CSV header contains names that are not plain identifiers, so it could be data.

What to do: Set has_header: false and declare column_names instead.

FIELD_NAME_UNTRUSTED — Sampled field names look like data

Discovery sampled an API resource whose JSON keys are not identifier-shaped (for example a map keyed by e-mail address). Such keys can be data, so they are never reported as field names.

What to do: Declare the resource's fields (or a JSON Schema) in the connection document's schema contract.

FIELD_TYPE_DRIFT — Field type changed

A document field holds a value whose type differs from the shape inferred from the sample, so the read stopped instead of coercing or dropping it.

What to do: Increase sample_size in the connection document, or rediscover the source; fields with mixed types can be read as text.

FIELD_TYPE_UNSUPPORTED — Selected field type is not supported

A field selected in the connection document has a type the SaaS connector cannot read (for example a base64 attachment body or an encrypted password field).

What to do: Remove the field from the object's field list.

FILE_TABLE_NOT_FOUND — Declared file table not found

A declared table path is missing or has the wrong file format.

What to do: Check the tables mapping and the configured format.

Operator runbook: docs/runbooks/source-unavailable.md

HTTP_ORIGIN_REFUSED — Request outside the configured API

A path, redirect or next-page link pointed outside the configured base URL (another host, port, scheme or a path above the base). The connector refuses it so the API's responses cannot steer the agent elsewhere.

What to do: Correct base_url or the resource path; if the API really pages across hosts, it cannot be read by this connector.

HTTP_RECORD_NOT_AN_OBJECT — API record is not a JSON object

While sampling a resource, a record was not a JSON object, so no field names could be derived.

What to do: Point records_pointer at the array of record objects, or declare the fields.

HTTP_RECORDS_NOT_A_LIST — Records pointer does not select a list

The JSON pointer configured for a resource (records_pointer) does not point to an array of JSON objects in the API response.

What to do: Fix records_pointer in the schema contract (an empty pointer means the whole response is the array).

HTTP_REDIRECT_REFUSED — Redirect refused

The API answered with a redirect that has no target or redirected too many times.

What to do: Point base_url at the final API location.

HTTP_REQUEST_REJECTED — API rejected the request

The API answered with a client error other than authentication, permission or not-found (for example 400 for an unknown query parameter). The response body is never logged.

What to do: Check the resource path, fixed params and pagination parameter names in the schema contract.

HTTP_RESPONSE_INVALID — Unexpected API response

The API response was not JSON or did not have the shape the connector expects.

What to do: Check that base_url and the paths point at the JSON API (not a login page or proxy), and the pinned API version.

HTTP_RESPONSE_TOO_LARGE — API response too large

A single API response exceeded max_response_bytes, so it was not read into memory.

What to do: Lower the page size of the resource or raise max_response_bytes deliberately.

KAFKA_AUTHENTICATION_FAILED — Kafka login failed

The Kafka brokers refused the SASL credential from the connection document.

What to do: Check the user, mechanism and secret reference, and that the credential is not disabled or expired.

KAFKA_COLUMN_NAME_CONFLICT — Kafka field name conflict

A JSON field uses the reserved kafka_ column prefix, or two fields differ only in letter case.

What to do: Declare the topic's columns explicitly in the connection document.

KAFKA_FIELD_NAME_UNTRUSTED — Kafka field name not usable

A JSON field name in the sample is not a plain identifier, so it is not exposed as a column (names leave the agent as metadata).

What to do: Declare the topic's columns explicitly, or read the topic as one binary or text value.

KAFKA_FIELD_TYPE_DRIFT — Kafka field type changed

A record's field does not match the column type inferred or declared for the topic.

What to do: Declare the topic's columns with the right types, or read the field as JSON text.

KAFKA_NOT_AUTHORIZED — Kafka read not authorized

The credential is not allowed to read or describe a configured topic.

What to do: Grant READ and DESCRIBE on the topic to the connector's principal (see the least-privilege guide).

KAFKA_VALUE_NOT_JSON — Kafka value is not JSON

A record value in a topic configured as JSON is not a JSON object.

What to do: Configure the topic to be read as binary or text, or fix the producer.

KAFKA_WINDOW_EXPIRED — Kafka records expired

Records inside the job's snapshot window were deleted by retention before they could be read.

What to do: Run the job again (a new window is resolved), or lengthen the topic's retention.

KEY_FIELDS_NOT_UNIQUE — Declared key is not unique

The key_fields declared for a collection or container are not covered by a unique, non-partial index, so they cannot be trusted as a key.

What to do: Declare fields covered by a unique index, or remove key_fields to use the document id.

MAINFRAME_FILE_TOO_LARGE — Variable-length file too large

A V/VB file exceeds the source's max_file_bytes limit (variable-length files are read in one pass).

What to do: Raise max_file_bytes in the connection document if the agent host has the memory, or split the unload.

MAINFRAME_INVALID_DATE — Invalid date field

A field declared in date_fields holds a value that is not a valid date in the declared format.

What to do: Check the date format declared for the field; all zeros or spaces are read as no date.

MAINFRAME_INVALID_NUMERIC — Invalid packed or zoned number

A packed-decimal or zoned-decimal field contains bytes that are not valid digits or a valid sign. The value is never partially decoded.

What to do: Check that the copybook matches the file (offsets, USAGE) and that the code page is right.

MAINFRAME_RECORD_FORMAT_UNSUPPORTED — Unsupported record format

The declared record format is not F, FB, V or VB.

What to do: Declare the record format of the unload file correctly.

MAINFRAME_RECORD_LENGTH_MISMATCH — Record length mismatch

A record's length, the file size or a block/record descriptor word does not match the copybook and record format.

What to do: Check that the right copybook and record format (F/FB vs V/VB) are declared for the file.

OBJECT_CHANGED_DURING_READ — Object changed during the read

An object was replaced or deleted while the agent was reading it. Reads are pinned to the object version seen when the read started, so the agent stops instead of mixing two versions.

What to do: Run the job again once the export that writes these objects has finished; do not overwrite files while a job reads them.

OBJECT_LISTING_LIMIT — Too many objects to list

Listing the configured bucket prefix returned more objects than max_list_objects, so the agent stopped rather than read a partial listing.

What to do: Narrow the prefix, declare the tables explicitly, or raise max_list_objects deliberately in the connection document.

OBJECT_TOO_LARGE — Object too large

An object in the file set is larger than max_object_bytes, so it was not read.

What to do: Split the export into smaller files, or raise max_object_bytes deliberately in the connection document.

READ_BUDGET_EXCEEDED — Read budget reached

The read stopped at the read-capacity budget configured for the source (for example max_scan_read_units).

What to do: Raise the budget in the connection document, or narrow the subset.

READ_LIMIT_EXCEEDED — Read bound exceeded

A resource or object has more pages or records than the configured max_pages / max_records. The read stops instead of returning a silently truncated table.

What to do: Raise the bound for this source, narrow the resource (fixed params, modified_since) or select fewer objects.

READ_ONLY_VIOLATION — Write-capable call refused

The connector refused to issue a call outside its read-only allow-list.

What to do: Nothing leaked or changed. Report the job to support with its correlation id.

RESOURCE_NOT_FOUND — API resource not found

The API answered 404 for a configured resource, object or table.

What to do: Check the path or API name and that the credential can see it.

SCHEMA_CONTRACT_INVALID — Schema contract is inconsistent

The declared schema contract does not describe the records: for example a JSON Schema that is not an object schema, id fields or relationships naming fields the resource lacks, or an object without an id field.

What to do: Fix the resources (or objects and aliases) in the connection document.

SOURCE_AUTH_FAILED — Credential refused

The source refused the credential (or the OAuth token endpoint refused the client credentials). No secret value is logged.

What to do: Rotate or correct the secret behind the reference and check the client's grant type and scopes.

SOURCE_AUTHENTICATION_FAILED — Source login failed

The source refused the credential from the connection document.

What to do: Check the user and the secret reference in the connection document, and that the account is not locked or expired.

SOURCE_PERMISSION_DENIED — Source permission denied

The source refused a read the connector needs, for example because SELECT was revoked from the connector's user after discovery.

What to do: Check the grants in the least-privilege guide for this connector, then rediscover the source.

SOURCE_QUERY_FAILED — Source query failed

A metadata query or read against the source failed. The query and values are never logged.

What to do: Check the credential's grants and the source's health; run discovery again.

Operator runbook: docs/runbooks/source-unavailable.md

SOURCE_QUERY_TIMEOUT — Source query timed out

A query or a network round trip did not finish within the configured statement timeout, so the agent stopped waiting. A stalled network path produces the same code.

What to do: Check the network path from the agent host to the source, and raise the statement timeout in the connection document only if the query is legitimately slow.

SOURCE_RATE_LIMITED — Rate limit still exceeded

The API kept answering 429 (Too Many Requests) after the bounded retries that honour Retry-After.

What to do: Lower max_requests_per_second, raise max_retries or max_backoff_s, or ask for a higher API limit.

SOURCE_THROTTLED — Source throttled the requests

The source kept answering with rate-limit responses after the agent's bounded retries.

What to do: Run the job again later or at a quieter time, or raise the service's request quota.

SOURCE_UNAVAILABLE — Source unavailable

The source could not be reached or the connection dropped mid-read.

What to do: Check network routes, DNS, TLS settings and credentials from the agent host.

Operator runbook: docs/runbooks/source-unavailable.md

SOURCE_VALUE_TYPE_MISMATCH — Value does not match the declared type

A record value could not be converted to the type declared for its field (for example text in an integer field). The value itself is never logged.

What to do: Correct the field's type in the schema contract (json or string accept anything).

TABLE_NOT_FOUND — Table not found

A table is not visible to this source's credential or schema filter.

What to do: Check schema filters and grants; re-run discovery after schema changes.

Operator runbook: docs/runbooks/schema-drift.md

TLS_CA_BUNDLE_MISSING — No CA bundle for TLS

The connector could not find a CA certificate bundle to verify the server's TLS certificate, so it did not connect.

What to do: Set the CA file in the connection document or install the operating system's CA certificates in the agent image.

TLS_HANDSHAKE_FAILED — TLS handshake failed

The TLS connection to the source could not be established or its certificate was not trusted.

What to do: Check the CA file or system trust store on the agent host and the host name in the connection document; never disable verification for production sources.

TLS_NOT_ENFORCED — Connection was not encrypted

The session could not be proven to be TLS-encrypted, so the connector refused it rather than read data over an unencrypted link.

What to do: Enable TLS on the server (or the listener) and keep certificate verification on in the connection document.

TLS_VERIFICATION_FAILED — TLS handshake or certificate check failed

The TLS handshake failed or the server certificate could not be verified, so nothing was read over an unverified connection.

What to do: Use the endpoint's TLS address and add its CA to ca_file (or the OS trust store); plain HTTP needs the explicit allow_plain_http opt-in.

Control plane (API and console) codes

AGENT_ALREADY_REVOKED — Agent already revoked

The agent was already revoked.

What to do: Nothing to do.

AGENT_CAPABILITY_DOWNGRADE — Agent capability downgrade

This agent previously verified signed job authorizations and now reports that it does not (for example an older image started with the same identity). It receives only cancellation and revocation work until this is resolved; nothing was published.

What to do: Run the current agent release with this identity, or revoke the agent and enroll a new one.

Operator runbook: docs/runbooks/agent-credential-reuse.md

AGENT_CUSTOM_SCHEMA_UNSUPPORTED — Agent too old for custom schemas

The job's agent does not advertise custom-schema support, so the build was failed instead of being sent to it.

What to do: Upgrade the agent to a release that supports custom schemas, then run the request again.

Operator runbook: docs/runbooks/test-data-api.md

AGENT_DELIVERY_GATE_UNSUPPORTED — Agent upgrade required

The job needs an agent that enforces delivery gates (a pending certification review or an environment expiry), and the assigned agent is older.

What to do: Upgrade the agent to the current release, then run the job again.

AGENT_DOCUMENT_SETS_UNSUPPORTED — Agent cannot read document sets

The request reads a DOCUMENTS source but the serving agent does not advertise DOCUMENT_SETS.

What to do: Upgrade the agent to a release that advertises DOCUMENT_SETS, then request again.

AGENT_ID_NOT_ALLOWED — Agent id not allowed on enrollment

An enrollment message must not carry an agent id.

What to do: Use the standard agent; do not hand-craft enrollment messages.

AGENT_ISOLATION_UNSUPPORTED — Agent cannot meet the required isolation

The job requires an execution isolation level (the organization's minimum, raised by the request) that the job's agent does not advertise (no ISOLATED_EXECUTION_* capability that satisfies it, or its runtime probe failed). The job was not dispatched.

What to do: Configure an isolation backend on that agent (docs/runbooks/isolated-execution.md) and check `datanivra-agent isolation doctor`, or have an organization admin review the minimum.

AGENT_MISMATCH — Sources and target on different agents

The sources and target environment of a request must be served by the same agent.

What to do: Pick sources and a target served by one agent.

AGENT_NOT_USABLE — Agent not usable

The selected agent does not exist or is revoked.

What to do: Choose an active agent.

AGENT_PACK_INTEGRITY_MISMATCH — Agent pack differs from the catalogue

The agent reports the pack's version with a different integrity digest than the catalogued one, so the job was not sent.

What to do: Redeploy the agent from the official signed image for this release, then run the request again.

AGENT_PACK_INTEGRITY_UNVERIFIED — Pack digest not catalogued

The catalogue entry of this pack version has no integrity digest to compare the agent's report with, so the job was not sent.

What to do: Ask your operator to re-register the pack catalogue (register-pack), then run the request again.

AGENT_PACK_MISSING — No agent can run this industry pack

The job's agent does not report the pack (older agents report no packs at all), so the job was not sent.

What to do: Upgrade the agent to a release that reports its installed packs and ships this pack, then run the request again.

AGENT_QUARANTINED — Agent quarantined

The agent's credential appears to be in use by more than one installation at the same time, and your organization's policy quarantines such agents. It receives only cancellation and revocation work; nothing was published.

What to do: Make sure exactly one process runs per agent identity, then revoke this agent and enroll a new one.

Operator runbook: docs/runbooks/agent-credential-reuse.md

AGENT_REPRO_UNSUPPORTED — Agent upgrade required for reproductions

A production-issue reproduction must be built under the reproduction profile, and the assigned agent does not advertise it (REPRO_PROFILE). The build was failed instead of being sent.

What to do: Upgrade the agent to a release with DataNivra Repro support and the default engine adapter, then request the reproduction again.

AGENT_REVOKED — Agent revoked

This agent has been revoked and can no longer call the control plane.

What to do: Enroll a new agent if needed.

Operator runbook: docs/runbooks/agent-offline.md

AGENT_STATUS_INVALID — Agent status invalid

Agents may only report ACTIVE or DEGRADED.

What to do: Upgrade the agent.

AGENT_TEXT_SPAN_MASK_UNSUPPORTED — Agent too old for TEXT_SPAN_MASK

The masking policy uses TEXT_SPAN_MASK but the serving agent does not advertise the TEXT_SPAN_MASK capability; the request was refused or the job failed closed instead of sending a command the agent would reject.

What to do: Upgrade the agent to a release that advertises TEXT_SPAN_MASK, then request again.

ALREADY_ATTESTED — Already attested

The source's sensitivity is already attested.

What to do: Nothing to do.

ALREADY_REVIEWED — Already reviewed

This dataset version has already been reviewed.

What to do: Nothing to do.

ALREADY_REVOKED — Already revoked

The dataset (version) is already revoked.

What to do: Nothing to do.

ASSERTION_INVALID — Agent assertion rejected

The agent's signed assertion was rejected.

What to do: Check the agent host clock and that the agent key was not replaced; re-enroll if needed.

Operator runbook: docs/runbooks/agent-offline.md

ASSERTION_REPLAYED — Agent assertion replayed

An agent assertion was used twice and was rejected.

What to do: Usually transient; if it persists, check for two agents sharing one state directory.

Operator runbook: docs/runbooks/agent-offline.md

AUTOMATIC_APPROVAL_UNAVAILABLE — Automatic approval not offered

This DataNivra deployment does not offer automatic approval of test-data requests, so a tenant cannot switch it on.

What to do: Leave the setting off; requests from workload identities wait for a human approver. Ask your DataNivra operator if automatic approval should be offered.

Operator runbook: docs/runbooks/test-data-api.md

BILLING_NOT_CONFIGURED — Billing not configured

Online checkout, plan changes or the billing portal are not configured on this DataNivra deployment yet.

What to do: Nothing is wrong with your organization: your trial and data are unaffected, and upgrading will be available here once online checkout is enabled.

CADENCE_INVALID — Refresh cadence invalid

The refresh cadence is not a valid cron expression.

What to do: Correct the cron expression.

CANNOT_DISABLE_SELF — Cannot disable yourself

You cannot disable your own account.

What to do: Ask another administrator.

CERTIFICATE_EXPIRED — Test-data certificate expired

The version's retention period ended, so its certificate expired and it is no longer provisioned.

What to do: Refresh the dataset to obtain a new certified version.

CERTIFICATE_INVALID — Test-data certificate does not verify

The version's stored certificate failed verification (signature, signing key or claims no longer match the version), so it is not provisioned.

What to do: Do not use this version. Build or refresh the dataset to obtain a newly certified version and contact support with the certificate id.

Operator runbook: docs/runbooks/certificate-signing-keys.md

CERTIFICATE_MISSING — Test-data certificate missing

The dataset version has no signed test-data certificate, so it is not provisioned.

What to do: Build or refresh the dataset to obtain a newly certified version; contact support if the version was certified recently.

CERTIFICATE_NOT_ISSUABLE — Certificate could not be issued

The version's recorded certification report, manifest or sources do not support a signed certificate (for example the report no longer matches the manifest), so the version was withdrawn.

What to do: Rebuild the dataset; if it repeats, contact support with the dataset id and version.

CERTIFICATE_REVOKED — Test-data certificate revoked

The version's certificate was revoked (the version was revoked, its certification review was rejected, or a policy or identity graph it relies on was revoked), so it is never provisioned.

What to do: Provision another certified version or build a new one.

Operator runbook: docs/runbooks/revoked-dataset.md

CERTIFICATE_SIGNING_UNAVAILABLE — Certificate signing unavailable

The control plane cannot sign test-data certificates (no signing key is configured), so builds are not dispatched and versions are not provisioned. No data was read or moved.

What to do: This is a DataNivra service configuration issue; retry later or contact support with the dataset id.

Operator runbook: docs/runbooks/certificate-signing-keys.md

CERTIFICATION_POLICY_MISMATCH — Certification policy mismatch

An agent's certification report referenced a different certification policy than the job.

What to do: Re-submit the request; contact support if it repeats.

Operator runbook: docs/runbooks/partial-evidence-upload.md

CERTIFICATION_REVIEW_REQUIRED — Certification review required

A human certification review must accept this version before it is used.

What to do: Ask a reviewer to accept the version in the console.

CHECKSUM_MISMATCH — Checksum mismatch

The reviewed content is not the content being approved (for example the version changed after review).

What to do: Review the current version again.

CLEANUP_JOB_NOT_CANCELLABLE — Cleanup job cannot be cancelled

The job removes a customer-side copy (dataset revocation, retention expiry or an ephemeral environment's teardown). Stopping it would leave the copy in place, so nobody can cancel it; the refusal is audited.

What to do: Let the job run. If the agent or target is unavailable, restore it: failed cleanup is retried automatically and alerted when overdue.

Operator runbook: docs/runbooks/revoked-dataset.md

CLI_LOGIN_ALREADY_DECIDED — Code already approved or denied

This sign-in code was already approved or denied; a decision is final.

What to do: If the CLI is still waiting, run datanivra login again for a new code.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_DENIED — CLI sign-in denied

Someone chose Deny for this sign-in code in the console, so the CLI was not signed in.

What to do: Run datanivra login again if you started it yourself and approve the new code.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_EXPIRED — Sign-in code invalid or expired

The code was never issued, was already used, or is older than 10 minutes.

What to do: Run datanivra login again and approve the new code within 10 minutes.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_PENDING — Waiting for approval

The CLI started a sign-in and nobody has approved its code in the console yet. The CLI keeps asking on its own.

What to do: Open the address the CLI shows in a browser where you are signed in to DataNivra, check the code and choose Approve.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_PERSON_REQUIRED — A person must approve

A CI workload session tried to approve a CLI sign-in. Only a person signed in to the console can.

What to do: Approve the code in the console as yourself.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_RATE_LIMITED — Too many sign-in attempts

Too many CLI sign-ins were started from this address, or too many codes were looked up by this person, in the last hour.

What to do: Wait up to an hour and try again; check the code carefully before entering it.

Operator runbook: docs/runbooks/cli-sign-in.md

CLI_LOGIN_SLOW_DOWN — Asking too often

The CLI asked whether its sign-in was approved sooner than allowed.

What to do: Nothing to do: the CLI waits longer between checks automatically.

Operator runbook: docs/runbooks/cli-sign-in.md

CONFLICT — Conflict

The request conflicts with the current state of the resource.

What to do: Reload and try again.

CURSOR_INVALID — Pagination cursor invalid

The pagination cursor is invalid or expired.

What to do: Start the listing again from the first page.

CUSTOM_SCHEMA_ARCHIVED — Custom schema archived

The custom schema is archived: it takes no new versions, and new test-data profile versions cannot name it. Profiles already approved keep their pinned version.

What to do: Create a new custom schema (or use a different one) and name it in the profile.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_EMPTY — No tables to copy

The source's latest discovery snapshot has no tables with columns, so there is nothing to copy into a custom schema.

What to do: Run discovery on the source again, or upload the structure as a definition instead.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_INVALID — Discovered structure not usable

The source's discovered structure does not form a valid custom schema (for example duplicate table or column names).

What to do: Select fewer tables with from_source.tables, or upload a corrected definition.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_NAME_TAKEN — Custom schema name taken

Your organization already has a custom schema with this name.

What to do: Choose another name, or add a new version to the existing custom schema.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_TABLE_UNKNOWN — Table not in the custom schema

A selected table, or a scenario's root_table, is not part of the custom schema (or the source's latest discovery snapshot).

What to do: Check the schema and table names (they are not case-sensitive) against the custom schema version.

Operator runbook: docs/runbooks/test-data-api.md

CUSTOM_SCHEMA_UNKNOWN — Custom schema not found

The test-data profile names a custom schema id or version that does not exist in your organization.

What to do: List your custom schemas (GET /v1/custom-schemas) and name an existing id and version.

Operator runbook: docs/runbooks/test-data-api.md

DATASET_MANIFEST_MISSING — Dataset manifest missing

Provisioning was refused because the version has no recorded manifest.

What to do: Provision a version that completed certification.

Operator runbook: docs/runbooks/corrupt-manifest.md

DATASET_MISMATCH — Dataset mismatch

An agent report named a dataset that does not belong to the job.

What to do: Contact support with the job id.

DATASET_NOT_FOUND — Dataset not found

The job's dataset or version no longer exists.

What to do: Re-submit the request.

DATASET_NOT_PROVISIONABLE — Dataset not provisionable

Only certified, non-revoked versions can be provisioned.

What to do: Certify a new version.

Operator runbook: docs/runbooks/revoked-dataset.md

DATASET_NOT_RESERVABLE — Dataset not reservable

Only a certified, unexpired, non-revoked dataset version can be reserved.

What to do: Reserve a certified version, or certify a new one first.

DATASET_RESERVED — Dataset reserved

Another user holds an active reservation of this dataset for a test run; it cannot be refreshed or rolled back now.

What to do: Wait until the reservation is released or expires, or ask its holder to release it.

DATASET_REVOKED — Dataset revoked

A revoked dataset cannot be refreshed or used; its open jobs are cancelled.

What to do: Request a new dataset.

Operator runbook: docs/runbooks/revoked-dataset.md

DATASET_VERSION_NOT_PROCESSING — Dataset version not processing

The version is no longer in PROCESSING, so the job or report was refused.

What to do: Re-submit the request if the version was cancelled.

Operator runbook: docs/runbooks/duplicate-refresh.md

DOCUMENT_SET_SUMMARY_MISSING — Document-set summary missing

A version built from a DOCUMENTS source cannot receive a test-data certificate without the agent's passing document-set summary.

What to do: Upgrade the agent to a release that advertises DOCUMENT_SETS and rebuild the version.

DOWNGRADE_EXCEEDS_LIMITS — Downgrade exceeds the smaller plan

Your organization currently uses more agents, sources or datasets than the smaller plan allows.

What to do: Revoke unused agents, remove sources or datasets named in the message, then change plan again.

DUPLICATE_SOURCE — Duplicate source

Each source may be listed once in a request.

What to do: Remove the duplicate.

EGRESS_METERING_UNAVAILABLE — Download usage not recorded yet

The size of an earlier download or export of your organization could not be recorded as usage (for example during a short database outage). Until it is recorded, further metered downloads and exports are refused, so download budgets cannot be bypassed. Other routes, reads and other organizations are not affected; operators receive an alert.

What to do: Retry after the number of seconds in the Retry-After header. The pending usage is recorded automatically on the next attempt once the platform is healthy. If it persists, contact support with the correlation id.

EMAIL_DOMAIN_NOT_ALLOWED — Email domain not accepted

Self-service sign-up does not accept addresses from this email domain.

What to do: Sign up with your work email address.

ENROLLMENT_TOKEN_EXPIRED — Sandbox enrollment expired

The hosted sandbox's agent did not enroll before its one-time enrollment token expired, so the sandbox was marked failed. None of your data is involved: the sandbox only uses synthetic data.

What to do: Reset the sandbox from the Sandbox page to start a fresh one.

Operator runbook: docs/runbooks/sandbox-runner.md

ENROLLMENT_TOKEN_INVALID — Enrollment token invalid

The enrollment token is unknown, expired or already used.

What to do: Create a new enrollment token in the console; tokens are one-time.

ENTITLEMENT_LIMIT_REACHED — Plan limit reached

Your plan's limit for this capacity (for example agents, sources or jobs) is reached.

What to do: Upgrade in Billing & Plan, or free capacity (for example revoke unused agents).

ENTITLEMENT_REQUIRED — Plan does not include this

Your plan does not include this feature or industry pack.

What to do: Upgrade in Billing & Plan.

ENVIRONMENT_EXPIRED — Environment expired

The target environment has expired.

What to do: Extend or recreate the environment.

ENVIRONMENT_EXPIRY_ALREADY_SET — Environment already has an expiry

set-environment-expiry only bounds a legacy ephemeral environment that has no expiry; it never extends an existing one.

What to do: Leave the expiry as it is, or register a new environment for longer use.

Operator runbook: docs/runbooks/ephemeral-environment-teardown.md

ENVIRONMENT_LEASED — Environment already leased

Another environment lease holds this ephemeral environment (one lease per environment).

What to do: Release the other lease, or attach a different ephemeral environment.

ENVIRONMENT_NAME_TAKEN — Environment name taken

An environment with this name already exists.

What to do: Choose another name.

ENVIRONMENT_NOT_EPHEMERAL — Environment is not ephemeral

Only an ephemeral environment gets an expiry through set-environment-expiry.

What to do: Check the environment id; permanent environments keep their copies until the dataset is revoked or expires.

Operator runbook: docs/runbooks/ephemeral-environment-teardown.md

ENVIRONMENT_NOT_FOUND — Environment not found

The target environment does not exist.

What to do: Choose an existing environment.

ENVIRONMENT_RESERVED — Environment reserved

Another user holds an active reservation of this environment; only they can provision into it.

What to do: Wait until the reservation is released or expires, or ask an environment manager to force-release it.

EPHEMERAL_EXPIRY_REQUIRED — Ephemeral environment needs an expiry

An ephemeral environment must say when it expires; at expiry the data DataNivra provisioned into it is torn down.

What to do: Set an expiry (at most 30 days ahead), or register the environment as non-ephemeral.

EPHEMERAL_TTL_TOO_LONG — Ephemeral lease too long

An ephemeral environment can expire at most 30 days after it is registered.

What to do: Choose an earlier expiry, or register a non-ephemeral environment.

EVAL_SET_NAME_TAKEN — Eval set name in use

An evaluation set with this name is already registered for the organization.

What to do: Register the manifest under another name.

EVENT_ID_CONFLICT — Event id conflict

An agent report reused an event id with different content.

What to do: Contact support with the job id.

Operator runbook: docs/runbooks/queue-duplication.md

EVIDENCE_INCOMPLETE — Evidence incomplete

The version's certification evidence is incomplete, so it cannot be used.

What to do: Request a new version.

Operator runbook: docs/runbooks/partial-evidence-upload.md

EXECUTION_SCOPE_DENIED — Job outside its synthetic-only scope

The job would open a source or target outside the DataNivra-hosted synthetic sandbox, but it runs under a synthetic-only scope (the Free plan, on deployments that offer it, or the hosted sandbox agent). It was refused before dispatch (or by the agent, which verifies the signed scope) and nothing was read.

What to do: Run synthetic work against the sandbox estates, or upgrade in Billing & Plan to use your own sources and targets.

Operator runbook: docs/runbooks/free-tier-and-trial.md

EXPIRY_IN_PAST — Expiry in the past

expires_at must be in the future.

What to do: Choose a future expiry.

EXPIRY_TIMEZONE_REQUIRED — Expiry needs a UTC offset

The expiry time was given without a UTC offset, so the moment it names is ambiguous.

What to do: Pass an ISO 8601 time with an offset, for example 2026-01-31T00:00:00+00:00.

EXPORT_WINDOW_INVALID — Export window invalid

The audit export's `until` is not after its `since`.

What to do: Send a `since` earlier than `until` (both with a UTC offset).

FEATURE_NOT_ENTITLED — Feature not in plan

The tenant's plan does not include this feature (the error names the feature, e.g. COMPLIANCE_GUARD).

What to do: Upgrade the plan or ask your DataNivra contact; nothing was changed.

FEATURE_REQUEST_CONTEXT_INVALID — Feature request names an unknown page, pack or connector

A feature request carried a page, industry pack or connector that DataNivra does not publish. Only published website and console pages, industry pack ids from the pack registry and connector slugs from the connector registry are accepted, so the hidden context cannot carry other text. It was refused before anything was stored, logged or e-mailed; the response names only the fields.

What to do: Open the "Request a feature" form from a DataNivra page (or send the request without page, pack or connector context) and submit it again. Integrations calling the API directly should send only published values or leave these fields out.

FEATURE_REQUEST_SENSITIVE_CONTENT — Feature request looks like real data

The title or description of a feature request looked like customer, production or personal data, a secret, or pasted records (for example an e-mail address, a card or account number, a connection string, or rows of a table). It was refused before anything was stored, logged or e-mailed; the response names only the fields.

What to do: Describe the need in your own words without real data: use made-up or generic examples (such as "a customer table with 300 columns") instead of values. To get a reply, use the separate optional e-mail field.

FINDING_REVIEWS_TOO_MANY — Too many finding reviews

The job would carry more reviewed findings than one command allows.

What to do: Split the request across fewer sources.

FORBIDDEN — Forbidden

You do not have permission to perform this action.

What to do: Ask an administrator for the needed role.

Operator runbook: docs/runbooks/tenant-authorization-failure.md

GUARD_AGENT_CHANGED — Guard scan agent changed

The environment is now served by another agent than the one the scan was queued for; the scan failed closed.

What to do: Request a new scan; it is queued for the environment's current agent.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_BASELINE_SCAN_INCOMPLETE — Baseline needs a complete scan

Only a complete compliance scan (no budget stop, cancellation or failure) can become an environment's baseline.

What to do: Fix the cause of the incomplete scan, run an on-demand scan and accept that one.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_ENVIRONMENT_EXISTS — Environment already guarded

This environment is already registered for Compliance Guard (at most once per environment).

What to do: Update the existing guarded environment instead.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_ENVIRONMENT_EXPIRED — Guarded environment expired

The environment's expiry has passed, so there is nothing to scan; the scan was refused or failed closed.

What to do: Pause the guarded environment or register a current environment.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_ENVIRONMENT_NOT_FOUND — Guarded environment not found

The guarded environment of a queued scan no longer resolves; the scan failed closed.

What to do: Check the guarded environment and request a new scan.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_FINDING_NOT_OPEN — Finding not open

Only an OPEN finding can be acknowledged, and only an unresolved one can be marked false positive.

What to do: Reload the finding; reopen it first if it was triaged.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_FINDING_NOT_SUPPRESSIBLE — Finding cannot be suppressed

Only an OPEN or ACKNOWLEDGED finding can be suppressed.

What to do: Reopen the finding first, then suppress it with an owner, a reason code and an end date.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_FINDING_NOT_TRIAGED — Finding not triaged

Only an acknowledged, suppressed or false-positive finding can be reopened.

What to do: Reload the finding; an OPEN finding needs no reopen.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_POLICY_MISMATCH — Guard policy mismatch

A compliance scan report names another compliance-guard policy version than the one dispatched; it was refused.

What to do: Upgrade the agent; the scan can be requested again.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_POLICY_NOT_APPROVED — Guard policy not approved

The compliance-guard policy has no approved version, so no scan can run against it.

What to do: Submit and approve a version of the COMPLIANCE_GUARD policy.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_POLICY_NOT_FOUND — Guard policy not found

The referenced policy does not exist in this tenant or is not a COMPLIANCE_GUARD policy.

What to do: Pick a COMPLIANCE_GUARD policy of this tenant.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_REPORT_MISMATCH — Guard report mismatch

A compliance scan report names another environment than its job; it was refused.

What to do: Upgrade the agent; the scan can be requested again.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SCAN_ALREADY_REPORTED — Scan already reported

The scan already has a different report; a second, different report is refused.

What to do: Request a new scan if the environment changed.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SCAN_RATE_LIMITED — Daily scan limit reached

The compliance-guard policy's max_scans_per_day for this environment is reached.

What to do: Wait for the next UTC day, or raise the limit in a new policy version.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SUPPRESSION_IN_PAST — Suppression end in the past

suppressed_until must be in the future.

What to do: Choose an end date in the future (at most 90 days ahead).

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SUPPRESSION_OWNER_INVALID — Suppression owner invalid

The owner of a suppression must be an active user of this tenant.

What to do: Pick an active user as the accountable owner.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_SUPPRESSION_TOO_LONG — Suppression too long

A suppression lasts at most 90 days; every suppression ends.

What to do: Choose an earlier end date and renew the suppression when it expires if still justified.

Operator runbook: docs/runbooks/compliance-guard.md

GUARD_TIER_NOT_COVERED — Tier not covered by the guard policy

The compliance-guard policy's approved version has no rule for the environment's tier.

What to do: Add a rule for the tier in a new policy version, approve it, and retry.

Operator runbook: docs/runbooks/compliance-guard.md

IDEMPOTENCY_IN_PROGRESS — Request in progress

A request with this Idempotency-Key is still in progress.

What to do: Wait and retry.

IDEMPOTENCY_KEY_INVALID — Idempotency key invalid

The Idempotency-Key header is malformed.

What to do: Send a UUID-style key.

IDEMPOTENCY_KEY_REUSED — Idempotency key reused

This Idempotency-Key was already used for a different request.

What to do: Use a new key per distinct request.

IDENTITY_* — Identity graph conflict

Submitting or approving an identity graph version was refused because one of its approved links cannot be used against the latest discovered schemas. The code names the first conflict: IDENTITY_COLUMN_UNKNOWN (a linked column or its source's discovery is missing), IDENTITY_DOMAIN_UNKNOWN, IDENTITY_TYPE_INCOMPATIBLE, IDENTITY_DUPLICATE_LINK, IDENTITY_COLUMN_IN_TWO_DOMAINS, IDENTITY_CONTRADICTORY_CYCLE, IDENTITY_SAME_SOURCE, IDENTITY_SOURCE_NOT_IN_TENANT. Only names and types are compared, never values.

What to do: Open the version's identity validation (GET /v1/policies/{id}/versions/{v}/identity-validation) for every conflict with an explanation, fix the links in a new version, and submit again.

IDENTITY_DOMAIN_POLICY_MISMATCH — Masking policy disagrees with the identity graph

An approved link in the pinned identity graph uses a masking domain that the request's masking policy (or the built-in domains) does not define identically. Agents pseudonymise with the masking policy's domains, so linked columns would not stay joinable the way the graph was approved. No request was created.

What to do: Add the graph's masking domain definitions to the masking policy (same name, kind and parameters), approve that version, and pin it on the request.

IDENTITY_GRAPH_AGENT_UNSUPPORTED — Agent too old for identity graphs

The job carries an approved identity graph, which agents before 0.3.0 cannot apply. The job was not sent to the agent.

What to do: Upgrade the agent serving these sources to 0.3.0 or later, then submit the request again.

IDENTITY_GRAPH_NOT_APPROVED — Identity graph version not approved

A dataset request or closure plan pinned an identity graph version that is not APPROVED (a draft, in review, or deprecated). Builds of existing requests keep using a deprecated version; new requests cannot pin it.

What to do: Pin an approved version of the identity graph, or submit this version and have a second person approve it.

IDENTITY_GRAPH_REVOKED — Identity graph version revoked

The pinned identity graph version was revoked, so no new request may pin it and queued builds or refreshes that pinned it are not dispatched.

What to do: Create a new request pinning another approved version (for example the previous one) to roll back.

IDENTITY_OVERLAP_ALREADY_REPORTED — Overlap already reported

The agent reported different results for an overlap job that already has results.

What to do: Request a new measurement; results of a job are never replaced.

IDENTITY_OVERLAP_NOTHING_TO_MEASURE — Nothing to measure

The identity-graph version has no proposed link.

What to do: Propose links (manually or from metadata suggestions) before requesting value-assisted matching.

IDENTITY_OVERLAP_RESULT_MISMATCH — Overlap report does not match the request

The agent reported results for links other than the ones requested.

What to do: Upgrade the agent; if it repeats, contact support with the job id.

IDENTITY_PROVIDER_UNAVAILABLE — Identity provider unreachable

The identity provider could not be reached during sign-in.

What to do: Try again; check your identity provider's status.

IDENTITY_ROOT_NOT_DISCOVERED — Root source not discovered

The closure plan's root table belongs to a source with no metadata discovery yet, so there is nothing to plan over.

What to do: Run discovery on the source, then preview the plan again.

IDENTITY_ROOT_TABLE_UNKNOWN — Root table not discovered

The closure plan's root table is not in its source's latest discovered schema.

What to do: Check the schema and table name, or re-run discovery if the table is new.

IDENTITY_SOURCE_NOT_IN_TENANT — Linked source not in your organization

An identity graph link names a source that is not one of your organization's sources (or does not exist). The version was not saved, or no overlap was measured.

What to do: Use source ids from your own source list; suggestions (POST /v1/identity-mapping/suggestions) only propose links between your sources.

IDENTITY_SOURCES_ON_DIFFERENT_AGENTS — Linked sources on different agents

Value-assisted matching compares two columns where they live, so every linked source must be served by the same agent.

What to do: Serve the linked sources from one agent, or measure links pairwise on an agent that reaches both systems.

ILLEGAL_POLICY_TRANSITION — Illegal policy transition

The policy version cannot move to the requested status from its current one.

What to do: Follow the policy lifecycle (draft, in review, approved).

INDUSTRY_PACK_NOT_ENTITLED — Industry pack not licensed

The job uses an industry pack that your current plan or license does not include (for example a pack enabled under an earlier plan), so it was not sent to the agent. No data was read.

What to do: Disable the pack or move to a plan that includes it (Billing & Plan in the console), then retry.

INTERNAL_ERROR — Internal error

An internal error occurred.

What to do: Retry; if it repeats, contact support and quote the correlation id.

INVALID_CREDENTIALS — Sign-in failed

The login could not be completed.

What to do: Try again or use the sign-in link; contact your administrator if your account is disabled.

INVENTORY_DUPLICATE_ENVIRONMENT — Inventory lists an environment twice

An agent's target inventory report named the same environment more than once and was refused.

What to do: Upgrade the agent; the standard agent reports each environment once.

INVITATION_LIMIT — Invitation limit reached

Your organization sent its daily allowance of invitation emails.

What to do: Invite the remaining teammates tomorrow; people already invited can sign in by email now.

ISOLATION_POLICY_CONFLICT — Requested isolation contradicts the organization's

The request restricts isolation backends so that none of the backends the organization permits is left.

What to do: Request a backend the organization allows (Organization → Execution isolation), or ask an organization admin.

ISOLATION_STAGE_NOT_ISOLATED — Work type not isolated by agents

An execution-isolation minimum is set, but compliance-guard scans still run inside the agent process, so they are refused rather than run unisolated.

What to do: Run compliance scans in an organization without an isolation minimum, or wait for an agent release that isolates them (RR-ISO-2).

JOB_AUTHORIZATION_CAPABILITY_REQUIRED — Agent too old for this job

This DataNivra service requires agents that verify signed job authorizations, and your agent does not advertise that capability, so the job was not sent. No data was read.

What to do: Upgrade the agent to the current release (see Downloads) and retry the job.

Operator runbook: docs/runbooks/job-authorization-keys.md

JOB_AUTHORIZATION_UNAVAILABLE — Job authorization unavailable

The control plane could not sign the job authorization your agent requires, so the job was not sent. No data was read.

What to do: This is a DataNivra service configuration issue; retry later or contact support with the job id.

Operator runbook: docs/runbooks/job-authorization-keys.md

JOB_CANCELLED — Job cancelled

The job was cancelled, so the agent's report was refused.

What to do: Nothing to do.

JOB_KIND_MISMATCH — Job kind mismatch

An agent report does not match the job's kind.

What to do: Upgrade the agent; contact support if it repeats.

JOB_NOT_FOUND — Job not found

An agent reported on a job that does not exist for its tenant.

What to do: Contact support with the agent id.

JOB_NOTIFY_REF_UNSUPPORTED — Invalid job notification secret reference

The job_notify_ref value does not use the required secret-reference format (env://DATANIVRA_NOTIFY_<NAME>).

What to do: Set job_notify_ref to a value in the form env://DATANIVRA_NOTIFY_<NAME> and ensure the named environment variable is configured on the control plane.

Operator runbook: docs/runbooks/job-notifications.md

JOB_TERMINAL — Job already finished

The job already finished, so it cannot be cancelled or reported on.

What to do: Nothing to do.

LAST_OWNER — Last owner

The tenant must keep at least one active organisation owner.

What to do: Add another owner first.

LEASE_EXPIRED — Environment lease expired

The lease reached its expiry; its environment is being torn down and it can no longer be renewed.

What to do: Create a new lease; renew earlier or use a longer --ttl next time.

LEASE_MAX_LIFETIME_REACHED — Lease at its absolute lifetime

The lease already runs until its absolute end (max_expires_at); renewals never pass it.

What to do: Release the lease and create a new one if the test run needs more time.

LEASE_MISMATCH — Lease mismatch

The lease id in the path does not match the message.

What to do: Upgrade the agent.

LEASE_NOT_OWNER — Not the lease owner

Only the user who holds an environment lease can renew or release it.

What to do: Use the owner's identity; an administrator with environment.manage can force a release.

LEASE_NOT_RENEWABLE — Lease cannot be renewed

Only a live (requested, hydrating or ready) lease can be renewed; this one has ended.

What to do: Create a new lease.

LEASE_RATE_LIMITED — Too many leases created

The tenant created more environment leases in the last hour than the configured rate allows.

What to do: Back off and retry later; CI re-runs of a live lease are not counted. Operators can raise DATANIVRA_ENVIRONMENT_LEASE_CREATES_PER_HOUR.

LEASE_RENEWAL_LIMIT — Lease renewal limit reached

The lease has been renewed the maximum number of times.

What to do: Release the lease and create a new one.

LEASE_TARGET_REQUIRES_ENVIRONMENT_MANAGE — Creating a lease environment needs environment.manage

A lease that creates a new environment (target) needs the environment.manage permission.

What to do: Attach an existing ephemeral environment with --environment-id, or ask an administrator.

MANIFEST_CHECKSUM_MISMATCH — Manifest checksum mismatch

An agent report's manifest checksum differs from the one recorded.

What to do: Request a new version.

Operator runbook: docs/runbooks/corrupt-manifest.md

MANIFEST_CONFLICT — Manifest conflict

A different manifest was already recorded for this version.

What to do: Request a new version.

Operator runbook: docs/runbooks/corrupt-manifest.md

MANIFEST_MISSING — Manifest missing

An agent report needed a manifest that was not supplied.

What to do: Retry; contact support if it repeats.

Operator runbook: docs/runbooks/partial-evidence-upload.md

MANUAL_BILLING — Billed by trial or contract

The organization is on a trial or an enterprise contract, which is not managed in the billing portal.

What to do: Choose a plan on Billing & Plan to start a subscription, or contact your account team for contract changes.

MESSAGE_EXPIRED — Message expired

The agent message is older than the retention window.

What to do: Check the agent host clock; the agent will send fresh reports.

METHOD_NOT_ALLOWED — Method not allowed

The HTTP method is not allowed for this resource.

What to do: Check the API reference.

MISSION_NOT_ACKNOWLEDGEABLE — Mission completes automatically

Sandbox missions complete when the real step succeeds (for example a certified dataset); they cannot be ticked off by hand.

What to do: Carry out the mission's step in the sandbox; progress updates automatically.

MODEL_POLICY_EXPIRED — Model-provider approval already expired

The APPROVED_EXTERNAL version's expires_at is not in the future, so approving it would have no effect.

What to do: Propose a new version with a future expires_at.

MODEL_PROVIDER_POLICY_EXISTS — Model-provider policy exists

The organization already has its single model-provider policy.

What to do: Add a new version to the existing policy (datanivra model-policy propose).

NEWER_VERSION_CERTIFIED — Superseded by a newer certified version

A newer version of the dataset received a certificate. The older certificate still verifies and its version can still be rolled back to unless it is revoked or expired.

What to do: Nothing to do; use the newest version unless you deliberately roll back.

NOT_FOUND — Not found

The resource was not found (also returned for other tenants' resources, so nothing is disclosed).

What to do: Check the id and your organisation.

NOT_SELF_SERVICE — Plan needs a contract

Enterprise and Private Cloud plans are sold under contract, not through online checkout.

What to do: Use the enterprise page or contact sales; Team and Business can be bought online.

NOTHING_TO_ATTEST — Nothing to attest

Production sources are governed as production; no attestation is needed.

What to do: Nothing to do.

NOTIFICATION_CHANNEL_INVALID — Notification channel invalid

The channel is missing a field its kind requires (WEBHOOK: URL and signing secret; SLACK: URL; EMAIL: recipients).

What to do: Provide the missing reference or recipients.

Operator runbook: docs/runbooks/compliance-guard.md

NOTIFICATION_CHANNEL_NAME_TAKEN — Channel name taken

A notification channel with this name already exists in the tenant.

What to do: Choose another name or update the existing channel.

NOTIFICATION_RECIPIENT_INVALID — Recipient invalid

Every e-mail recipient must be an active user of this tenant.

What to do: Pick active users of this tenant.

NOTIFICATION_SECRET_REF_UNSUPPORTED — Unsupported notification secret reference

Webhook URLs and signing secrets must be references the control plane resolves: env://DATANIVRA_NOTIFY_<NAME>.

What to do: Ask the operator to provision the secret and use its env://DATANIVRA_NOTIFY_ reference.

Operator runbook: docs/runbooks/compliance-guard.md

NOTIFICATION_TEST_FAILED — Test event not queued

The test event could not be queued.

What to do: Retry; contact support if it persists.

OIDC_NOT_CONFIGURED — OIDC single sign-on not configured

Sign-in with an identity provider is not configured for this deployment.

What to do: Use the sign-in method your administrator configured.

ON_DEMAND_REFRESH_DISABLED — On-demand refresh disabled

The refresh policy does not allow on-demand refreshes.

What to do: Wait for the scheduled refresh or change the refresh policy.

Operator runbook: docs/runbooks/duplicate-refresh.md

PACK_DEPENDENCY_INACTIVE — Required pack not active

This pack depends on another industry pack that is not active for your organization.

What to do: Activate the packs this pack depends on first, then activate it again.

PACK_DEPENDENCY_NOT_CATALOGUED — Required pack not available

A pack this pack depends on is not in the catalogue of this environment.

What to do: Ask your operator to register the missing pack (register-pack); the pack cannot be activated until then.

PACK_INTEGRITY_UNVERIFIED — Pack integrity not verified

This pack version was registered without an integrity digest, so it cannot be activated (fail closed).

What to do: Ask your operator to re-register the pack catalogue with the current control-plane image (register-pack), then activate again.

PACK_NO_PREVIOUS_VERSION — No earlier pack version

There is no earlier version of this pack to roll back to.

What to do: Nothing to roll back; upgrade instead when a newer version is catalogued.

PACK_NOT_ACTIVE — Industry pack not active

The pack must be activated for your organization before its version can change or its policy templates can be used.

What to do: Activate the pack in Industry packs, then try again.

PACK_NOT_ENABLED — Industry pack not enabled

The industry pack is not enabled for this tenant.

What to do: Enable the pack (if your plan includes it).

PACK_TEMPLATE_KEY_REF_REQUIRED — Masking key reference required

A selected template keeps identities linked across systems and needs your masking key reference.

What to do: Provide key_ref, e.g. vault://your-vault/tdm-masking-key, then create the drafts again.

PACK_TEMPLATES_UNAVAILABLE — Pack templates not registered

This pack version was registered without its policy templates.

What to do: Ask your operator to re-register the pack catalogue (register-pack); create policies manually meanwhile.

PACK_VERSION_NOT_CATALOGUED — Pack version not available

The requested pack version is not in the catalogue.

What to do: Choose one of the catalogued versions shown on the pack's page.

PACK_VERSION_NOT_NEWER — Not a newer pack version

Upgrades move to a newer catalogued version than the active one.

What to do: Pick a newer version, or use rollback to return to the previous one.

PAYLOAD_TOO_LARGE — Payload too large

The request body is too large.

What to do: Send a smaller request.

PLAN_RATE_LIMITED — Plan request rate reached

Your organization (or you) started more work-creating, compute-heavy or download requests in the last minute than your plan allows. The budget depends on the plan (the Free plan, where it is offered, is the strictest) and is shared by everyone in the organization; details name the plan tier. Reads, billing and upgrade, revocation, cancellation and other clean-up are never limited.

What to do: Wait for the number of seconds in the Retry-After header and retry. If your team regularly hits it, upgrade in Billing & Plan for a higher budget.

Operator runbook: docs/runbooks/free-tier-and-trial.md

PLAN_SYNTHETIC_ONLY — Your plan is synthetic-only (Free)

Applies only on deployments that offer the permanent Free plan. The Free plan runs the hosted synthetic sandbox, playground and fixtures only. Customer sources, customer agents and target environments in your own infrastructure need a trial or a paid plan. A queued job for a customer agent that fails with this code was refused before anything was sent; no data was read.

What to do: Upgrade in Billing & Plan to work with your own sources. The synthetic sandbox keeps working on Free.

Operator runbook: docs/runbooks/free-tier-and-trial.md

PLAN_UNCHANGED — Already on this plan

The organization is already on the selected plan.

What to do: No action needed.

POLICY_CHECKSUM_MISMATCH — Policy checksum mismatch

The referenced policy checksum does not match.

What to do: Reference the current policy version.

Operator runbook: docs/runbooks/expired-policy.md

POLICY_KIND_MISMATCH — Policy kind mismatch

The referenced policy is not of the expected kind.

What to do: Reference a policy of the right kind (masking, certification, refresh ...).

POLICY_NAME_TAKEN — Policy name taken

A policy with this name already exists.

What to do: Choose another name.

POLICY_NOT_APPROVED — Policy not approved

The referenced policy version is not approved (a job may be refused at dispatch for this reason).

What to do: Approve the version or reference an approved one.

Operator runbook: docs/runbooks/expired-policy.md

POLICY_NOT_FOUND — Policy not found

The referenced policy version does not exist.

What to do: Choose an existing version.

POLICY_REF_MISMATCH — Policy reference mismatch

An agent report referenced a different policy than the job.

What to do: Re-submit the request; contact support if it repeats.

POLICY_REVOKED — Policy version revoked

The referenced policy version was revoked; work that depends on it is refused or fails closed.

What to do: Use an approved, unrevoked version.

PORTAL_NOT_AVAILABLE — Billing portal not available yet

The billing provider's portal becomes available after your first checkout.

What to do: Choose a plan first; afterwards manage payment methods and invoices in the portal.

PROFILE_NOT_FOUND — Test-data profile not found

No test-data profile with this name and version exists in your tenant.

What to do: Check the profile name and version (`datanivra test-data profiles`); pin an approved version.

Operator runbook: docs/runbooks/test-data-api.md

PROTOCOL_VERSION_UNSUPPORTED — Protocol version unsupported

The agent speaks a protocol version this control plane does not support.

What to do: Upgrade the agent (see the downloads page).

PUBLIC_KEY_IN_USE — Public key in use

Another agent already enrolled with this public key.

What to do: Give each agent its own state directory and key.

RATE_LIMITED — Rate limited

Too many requests in a short time.

What to do: Wait and retry; the response carries a retry hint.

REDIRECT_URI_NOT_ALLOWED — Callback URL not allowed

The sign-in callback URL is not registered.

What to do: Use the console's configured address.

REFRESH_RATE_LIMITED — Refresh limit reached

The refresh policy's daily refresh limit was reached.

What to do: Wait until tomorrow or adjust the refresh policy.

Operator runbook: docs/runbooks/duplicate-refresh.md

REPORT_KIND_UNSUPPORTED — Report kind unsupported

The agent sent a report kind the control plane does not accept for this job.

What to do: Upgrade the agent.

REPRO_ACCESS_DENIED — Not allowed to provision this reproduction

Only the requester, the approver of the request or a user who may approve dataset requests (dataset.approve) can provision, roll back or lease a reproduction. The attempt was audited.

What to do: Ask the requester or a data owner to provision it, or have a data owner grant you the role.

REPRO_CLOSURE_UNBOUNDED — Reproduction closure must be bounded

A reproduction needs relationships.max_selected_rows (at most 10,000,000) and relationships.max_fan_out so it cannot grow beyond the incident's records.

What to do: Set both bounds on the subset's relationship policy and submit again.

REPRO_JUSTIFICATION_REQUIRED — Justification required

A reproduction needs a short justification for the approver: a reason code or one line of at most 500 characters.

What to do: Add a justification such as INCIDENT_TRIAGE and submit again.

REPRO_JUSTIFICATION_SENSITIVE — Justification looks like it contains a record value

The justification matched a boundary detector (for example an e-mail address, a card or account number, or a person's name). It was refused and not stored.

What to do: Reference the ticket key instead of naming customers or records.

REPRO_NOT_READY — Reproduction not built yet

The reproduction has no certified version yet (approval or build pending), so it cannot be handed to an environment lease.

What to do: Wait until the request is fulfilled and its certificate issued, then request the lease again.

REPRO_PURPOSE_MISMATCH — Lease purpose differs from the reproduction's ticket

An environment lease of a reproduction is always for the reproduction's own ticket. A different purpose_ref was refused.

What to do: Omit purpose_ref (the ticket key is used) or give the reproduction's ticket key.

REPRO_RETENTION_TOO_SHORT — Lease would outlive the reproduction

The requested lease TTL is longer than the time left before the reproduction expires. A lease never outlives the data it holds.

What to do: Request a shorter TTL.

REPRO_ROOT_CAP_REQUIRED — Root cap required

A reproduction must cap the number of root records it selects (fixed_count, at most 10,000).

What to do: Set fixed_count on the subset to the most affected records you expect.

REPRO_SEED_HANDLE_REQUIRED — Seed list handle required

A reproduction names its affected records only through an agent-local seed list handle (seedlist://<name>). A path, bucket URI or other reference was refused because it can carry identifiers or reveal where incident data lives.

What to do: Place the list in the agent's seed-list directory and reference it as seedlist:// followed by the file name.

REPRO_TEXT_SENSITIVE — Title looks like it contains a record value

The title or business domain of a reproduction matched a boundary detector. It was refused and not stored.

What to do: Use the ticket key (e.g. Repro OPS-1234) instead of naming customers or records.

REQUEST_NOT_AWAITING_APPROVAL — Request not awaiting approval

The dataset request is not in a state that can be approved or rejected.

What to do: Reload the request.

REQUEST_NOT_CANCELLABLE — Request not cancellable

The dataset request can no longer be cancelled.

What to do: Reload the request.

RESERVATION_ENDED — Reservation already ended

The reservation was released, expired or ended by a revocation.

What to do: Take a new reservation.

RESERVATION_NOT_OWNER — Not the reservation holder

Only the user holding a reservation can renew or release it.

What to do: Ask the holder, or a user with environment.manage, to release it.

RESERVATION_RENEWAL_LIMIT — Renewal limit reached

The reservation was renewed the maximum number of times.

What to do: Release it and take a new reservation.

REVIEW_REQUIRED — Review required

An approval-required policy version must be submitted for review before approval.

What to do: Submit the version for review first.

REVIEW_STATUS_INVALID — Review status invalid

A finding review must confirm or reject the finding.

What to do: Choose confirm or reject.

ROLE_ESCALATION_DENIED — Role escalation denied

You cannot grant roles with permissions you do not hold.

What to do: Ask an administrator who holds the role.

RUNNER_FAILED — Sandbox runner failed

The hosted sandbox runner reported a failure without a more specific code. The sandbox only uses synthetic data; none of your data is involved.

What to do: Reset the sandbox from the Sandbox page. If it fails again, contact support.

Operator runbook: docs/runbooks/sandbox-runner.md

SANDBOX_AGENT_NOT_READY — Sandbox still starting

The hosted sandbox agent has not reported in yet.

What to do: Wait a minute and reload the sandbox page. If it stays in this state, reset the sandbox.

SANDBOX_AGENT_SYNTHETIC_ONLY — The sandbox agent serves synthetic data only

The DataNivra-hosted sandbox agent only opens the synthetic sandbox estates and targets. It can never be pointed at one of your own sources or targets (production data stays in your environment).

What to do: Install an agent in your own environment for your own sources (a trial or a paid plan), or use the sandbox estates.

SANDBOX_CUSTOM_SCHEMA_LIMIT — Sandbox build too large

In the hosted sandbox, a build from your custom schema may name at most 5 root tables with at most 1,000 rows each (child tables follow through foreign keys).

What to do: Ask for fewer rows or root tables, or run the build on your own DataNivra agent, where your profile's limits apply.

Operator runbook: docs/runbooks/test-data-api.md

SANDBOX_EGRESS_BUDGET_EXCEEDED — Download budget used

Your organization downloaded as many bytes of exports (certificate packages, evidence and audit exports, repro bundles, eval-set exports) today or this month as your plan includes (Billing & Plan shows EGRESS_BYTES_PER_DAY and EGRESS_BYTES_PER_MONTH). The website's static synthetic fixtures are not counted.

What to do: Retry after the Retry-After header (the next UTC day, or month for the monthly budget), or upgrade for a larger budget.

Operator runbook: docs/runbooks/free-tier-and-trial.md

SANDBOX_ESTATES_INVALID — Sandbox runner report invalid

The hosted sandbox runner reported estates that do not belong to the sandbox.

What to do: Reset the sandbox; if it repeats, contact support (runner configuration issue).

SANDBOX_NOT_PROVISIONING — Sandbox not starting

The sandbox runner reported on a sandbox that is not being started.

What to do: Reload the sandbox page; if the sandbox shows FAILED, reset it.

SANDBOX_PACK_NOT_OFFERED — Synthetic estate not offered

A requested synthetic estate (industry pack) is not available in the hosted sandbox.

What to do: Start the sandbox with the default estates.

SANDBOX_REF_INVALID — Sandbox reference outside the sandbox

A sandbox source, target or key reference pointed outside the sandbox's own documents and was refused.

What to do: Reset the sandbox; if it repeats, contact support. Sandboxes only ever use DataNivra-hosted synthetic estates.

SANDBOX_RESET_LIMIT — Sandbox reset limit reached

The sandbox was reset the maximum number of times in the last 24 hours.

What to do: Keep using the current sandbox, or reset it again later.

SANDBOX_RUNNER_UNAVAILABLE — Hosted sandbox unavailable

This DataNivra deployment does not run the hosted synthetic sandbox yet.

What to do: Use the browser demo on the website, or install an agent in your own environment with synthetic data.

SANDBOX_STORAGE_BUDGET_EXCEEDED — Sandbox storage budget used

The synthetic datasets and outputs of your hosted sandbox use the storage your plan includes (Billing & Plan shows the SANDBOX_STORAGE_BYTES row). New sandbox work was refused before it started; nothing was deleted.

What to do: Revoke sandbox datasets you no longer need or reset the sandbox (both always work and free the space), or upgrade for a larger budget.

Operator runbook: docs/runbooks/free-tier-and-trial.md

SANDBOX_TEMPLATE_INVALID — Sandbox policy template invalid

A policy template supplied by the sandbox runner is not a valid policy.

What to do: Reset the sandbox; if it repeats, contact support.

SENSITIVITY_MISMATCH — Sensitivity mismatch

The attested sensitivity differs from the declared one.

What to do: Attest the declared sensitivity or change the source's declaration.

SEPARATION_OF_DUTIES — Separation of duties

The author or submitter of a policy version cannot approve it.

What to do: Ask another approver.

SEQUENCE_CONFLICT — Report sequence conflict

An agent replayed an older report sequence with different content.

What to do: Usually harmless replay; contact support if the job stalls.

Operator runbook: docs/runbooks/queue-duplication.md

SEQUENCE_GAP — Report sequence gap

An agent report skipped a sequence number; the job waits for the missing report.

What to do: Let the agent retry from its outbox; contact support if the job stalls.

Operator runbook: docs/runbooks/queue-duplication.md

SIGNUP_CAPACITY_REACHED — Sign-ups paused

The daily limit of new self-service organizations was reached.

What to do: Try again tomorrow; the synthetic playground is available meanwhile. For an urgent evaluation, contact sales.

SIGNUP_NOT_AVAILABLE — Self-service sign-up not offered

This DataNivra deployment does not offer self-service sign-up or email sign-in.

What to do: Sign in with your organization's identity provider, or contact the deployment's administrator.

SIGNUP_NOT_CONFIGURED — Sign-up not configured

Self-service sign-up is enabled but its trial set-up is not configured on the server.

What to do: Contact support; this is a deployment configuration issue.

SIGNUP_ORGANIZATION_LIMIT — Trial limit for this address

This email address created the maximum number of trial organizations recently.

What to do: Continue in an organization you already created (sign in by email).

SIGNUP_SOURCE_LIMIT — Sign-up limit for this network

Many organizations were created from this network or email domain today.

What to do: Try again tomorrow, or continue in an organization you already created (sign in by email). The synthetic playground is available meanwhile.

SOD_POLICY_APPROVAL_REQUIRED — Separation of duties required

Separation of duties for policy approval cannot be switched off on this tenant.

What to do: Keep policy approval separation of duties on.

SOURCE_MISMATCH — Source mismatch

An agent report named a source that does not belong to the job.

What to do: Contact support with the job id.

SOURCE_NAME_TAKEN — Source name taken

A source with this name already exists.

What to do: Choose another name.

SOURCE_NOT_FOUND — Source not found

A referenced source does not exist.

What to do: Choose an existing source.

SUBSCRIPTION_NOT_CHANGEABLE — Plan change not possible now

An invoice is past due or the subscription is cancelled, so the plan cannot change.

What to do: Open Manage billing to pay the open invoice or resume the subscription, then change plan.

SUBSCRIPTION_NOT_FOUND — No active subscription

There is no active self-service subscription to change or cancel.

What to do: Choose a plan on Billing & Plan first.

SYNTHETIC_SCHEMA_REQUIRED — Industry pack or custom schema required

A synthetic-only test-data profile reads no source, so it must name where its tables come from: an industry pack or a custom schema.

What to do: Set build.pack_id (and the scenarios' pack_id) to an industry pack, or set build.custom_schema to one of your custom schemas (scenarios then name a root_table).

Operator runbook: docs/runbooks/test-data-api.md

TARGET_POOL_EXHAUSTED — Every approved target is in use

All targets in the profile's pool hold a live test-data request, so no isolated copy can be created now.

What to do: Retry after a running request is released, or ask the profile owner to add targets to the pool in a new profile version.

Operator runbook: docs/runbooks/test-data-api.md

TENANT_ADMIN_REQUIRED — Tenant administrator required

Only a tenant administrator (org.admin) who is neither the author nor the submitter may approve a model-provider policy version. The denial was audited.

What to do: Ask a tenant administrator to review and approve the version.

TENANT_MISMATCH — Tenant mismatch

A report or request referenced another tenant and was refused.

What to do: Contact support with the job id.

Operator runbook: docs/runbooks/tenant-authorization-failure.md

TENANT_NOT_ACTIVE — Organization not active

The organization is suspended or closed, so its agents and sandbox cannot connect.

What to do: An organization owner can check Billing & Plan; if the suspension is unexpected, contact support.

TENANT_SLUG_TAKEN — Organisation address taken

An organisation with this slug already exists.

What to do: Choose another slug.

TEST_DATA_PROFILE_NAME_INVALID — Test-data profile name invalid

Profile names are used in CI files and manifests, so they must be portable slugs.

What to do: Use lower-case letters, digits, '.', '_' and '-' (at most 63 characters).

Operator runbook: docs/runbooks/test-data-api.md

TEST_DATA_PROFILE_NOT_USABLE — Profile version no longer approved

The test-data request was created from a profile version that has since been revoked or deprecated, so it cannot be scheduled.

What to do: Reject the pending request and invoke an approved profile version instead.

Operator runbook: docs/runbooks/test-data-api.md

TEST_DATA_PROFILE_REFERENCE_UNKNOWN — Profile names an unknown resource

The profile names a source, environment, dataset, agent, policy or workload identity that does not exist in your tenant.

What to do: Correct the reference in the profile (the error names the field) and create a new version.

Operator runbook: docs/runbooks/test-data-api.md

TEST_DATA_REQUEST_DENIED — Test-data request denied

The request is outside what the approved profile allows; the details list the reason codes (for example COUNT_EXCEEDS_PROFILE_MAXIMUM or WORKLOAD_NOT_PERMITTED_BY_PROFILE).

What to do: Stay within the profile's bounds, or ask the profile owner for a new, reviewed profile version. Nothing was created.

Operator runbook: docs/runbooks/test-data-api.md

TEST_DATA_REQUEST_NOT_OWNER — Not your test-data request

Only the requester can release a test-data request (an administrator with environment.manage may force it).

What to do: Release it with the identity that requested it.

Operator runbook: docs/runbooks/test-data-api.md

TEST_DATA_REQUEST_NOT_PENDING — Test-data request not pending

Only a request waiting for approval can be approved or rejected.

What to do: Refresh the request; it was decided or ended already.

Operator runbook: docs/runbooks/test-data-api.md

TEXT_SPAN_RULE_MISSING — TEXT_SPAN_MASK rule required

A dataset request reads a DOCUMENTS source, but its masking policy has no TEXT_SPAN_MASK rule.

What to do: Add a TEXT_SPAN_MASK rule on the documents table's text column to the masking policy, approve it and request again.

TIMEZONE_INVALID — Time zone invalid

The refresh policy time zone is unknown.

What to do: Use an IANA time zone name such as Europe/Berlin.

TIMEZONE_REQUIRED — Time zone required

from/to query values must include a UTC offset.

What to do: Add a UTC offset to the timestamps.

TREND_WINDOW_INVALID — Trend window invalid

until must be after since and the window at most 366 days.

What to do: Narrow the window.

UNAUTHENTICATED — Not signed in

Authentication is required.

What to do: Sign in again.

UNEXPECTED_MESSAGE_KIND — Unexpected message kind

The endpoint does not accept that agent message kind.

What to do: Upgrade the agent.

UNKNOWN_POLICY_TEMPLATE — Unknown policy template

A requested template code is not part of the active pack version.

What to do: Use a template code listed on the pack's page.

USER_EXISTS — User exists

A user with this email already exists in the organisation.

What to do: Invite a different address or edit the existing user.

USER_REQUIRED — User required

This action must be performed by a signed-in user, not an agent or token.

What to do: Sign in as a user.

VALIDATION_FAILED — Validation failed

The request is invalid; the details list the affected field paths (never the values).

What to do: Correct the listed fields.

VALUE_ASSISTED_MATCHING_DISABLED — Value-assisted matching not enabled

The identity-graph version did not opt in to value-assisted matching.

What to do: Create a version with value_assisted_matching enabled and have it approved.

VALUE_ASSISTED_MATCHING_NOT_APPROVED — Value-assisted matching not approved

The policy's approved identity-graph version has not opted in, so an author cannot switch value reading on alone (separation of duties).

What to do: Have an approver approve a version with value_assisted_matching enabled first.

VERSION_NOT_CERTIFIED — Version not certified

Only certified versions can be reviewed.

What to do: Wait for certification to complete or request a new version.

WINDOW_INVALID — Window invalid

The calendar window must be positive and at most 366 days.

What to do: Choose a shorter window.

WORKLOAD_IDENTITY_DISABLED — Workload identity not enabled

This DataNivra deployment does not accept CI workload identity tokens.

What to do: Use a user session, or ask your DataNivra operator whether workload identity can be enabled.

Operator runbook: docs/runbooks/test-data-api.md

WORKLOAD_IDENTITY_NAME_TAKEN — Workload identity name taken

An active workload identity already has this name.

What to do: Choose another name, or disable the existing trust first.

Operator runbook: docs/runbooks/test-data-api.md

WORKLOAD_IDENTITY_UNAVAILABLE — Workload identity unavailable

The workload token verifier is not available on this server.

What to do: Retry later; contact support with the correlation id if it persists.

Operator runbook: docs/runbooks/test-data-api.md

WORKLOAD_ISSUER_NOT_ALLOWED — CI token issuer not allowed

The trust names a token issuer that the DataNivra operator has not allow-listed.

What to do: Use the provider's public issuer, or ask your operator to allow-list your self-managed GitLab.

Operator runbook: docs/runbooks/test-data-api.md

WORKLOAD_SESSION_NOT_REFRESHABLE — Workload session cannot be refreshed

Workload sessions are short and never extended.

What to do: Exchange a fresh CI token (`datanivra login --workload-identity ...`).

Operator runbook: docs/runbooks/test-data-api.md

Command line (certificate verification) codes

These codes come from datanivra certificates verify, which checks a test-data certificate offline. Each has its own exit code so a CI step can tell them apart. A certificate means DataNivra-certified against your configured policy gates; it is not a regulatory, legal or third-party certification.

AGENT_CLI_NOT_FOUND — Agent command not installed

datanivra documents scan --dry-run runs the customer-side datanivra-agent command locally, and it was not found (exit 33).

What to do: Install the DataNivra agent on this machine or pass --agent-cli with its path.

CERTIFICATE_KEY_NOT_VALID — Signing key not valid at issue time

The certificate's issue time is outside the signing key's published validity window (before it was first used or after it was retired).

What to do: Treat the certificate as untrusted and contact your DataNivra administrator. Exit code 11.

CERTIFICATE_KEY_SUBSTITUTED — Package key replaced

The package carries a different public key under a key id you trust: someone swapped the verification key.

What to do: Do not use the package. Download it again from DataNivra and verify it against your own trusted key set. Exit code 18.

CERTIFICATE_KEY_UNKNOWN — Signing key not trusted

The certificate was signed with a key that is not in the key set you trust. Either the key set is outdated or the certificate was signed by someone else.

What to do: Refresh your trusted key set from the published keys; if the key id is still unknown, do not use the dataset and contact your DataNivra administrator. Exit code 11.

CERTIFICATE_KEYS_MALFORMED — Trusted key set invalid

The --keys file is not a certificate key set, or one of its keys is not an Ed25519 key whose id is the first 16 hex characters of SHA-256 over the public key, or an id appears twice.

What to do: Download the published key set again (`datanivra certificates keys --out keys.json`) from a source you trust. Exit code 10.

CERTIFICATE_MALFORMED — Not a certificate or package

The file given to `datanivra certificates verify` (or its --status file) is not valid JSON or does not match the DataNivra certificate, package or status format. Nothing from the file is shown.

What to do: Pass the JSON evidence package (`datanivra certificates download ID`) or the certificate exactly as downloaded; do not edit it. Exit code 10.

CERTIFICATE_MANIFEST_MISMATCH — Manifest checksum differs

The certified manifest checksum is not the one passed with --manifest-checksum: the certificate is for different data.

What to do: Check that you are verifying the certificate of the dataset version you provisioned. Exit code 15.

CERTIFICATE_SIGNATURE_INVALID — Certificate signature invalid

The certificate's Ed25519 signature does not verify: its claims were changed after signing, or it was not signed by the trusted key.

What to do: Do not use the dataset version. Download the package again; if it still fails, contact your DataNivra administrator. Exit code 12.

CERTIFICATE_STATE_NOT_ACCEPTED — Certificate state not accepted

The certificate is REVOKED or EXPIRED (or a state you excluded with --require-state). A revoked or expired dataset version must not be used.

What to do: Use a dataset version with a current certificate; see the certificate's reason code in the console. Exit code 14.

CERTIFICATE_STATUS_KEY_NOT_VALID — Status key not valid at statement time

The status statement's time is outside its signing key's published validity window.

What to do: Fetch a fresh status with --online and verify again. Exit code 11.

CERTIFICATE_STATUS_KEY_UNKNOWN — Status signing key not trusted

The status statement was signed with a key that is not in your trusted key set.

What to do: Refresh your trusted key set; if the key stays unknown, treat the status as untrusted. Exit code 11.

CERTIFICATE_STATUS_MISMATCH — Status is about something else

The status statement names a different certificate, tenant, dataset or version, or predates the certificate (a replayed or mixed-up status).

What to do: Use the status that belongs to this certificate: download the package again or use --online. Exit code 13.

CERTIFICATE_STATUS_MISSING — No status statement

A bare certificate was given without a signed status statement, so revocation cannot be checked.

What to do: Verify the full package, pass --status FILE, or use --online to fetch the current status. Exit code 16.

CERTIFICATE_STATUS_SIGNATURE_INVALID — Status signature invalid

The status statement's signature does not verify: its state or other fields were changed after signing.

What to do: Do not rely on the status. Fetch a fresh one with --online. Exit code 12.

CERTIFICATE_STATUS_STALE — Status statement too old

The signed status statement is older than --max-status-age allows.

What to do: Fetch a fresh status with --online (or download a new package) and verify again. Exit code 16.

CERTIFICATE_TRUST_ANCHOR_MISSING — No trusted keys given

Verification needs keys you trust and none were given.

What to do: Pass --keys KEYS.json (recommended; download with `datanivra certificates keys`), or --online, or explicitly --trust-package-keys. Exit code 17.

DOCUMENT_SCAN_FAILED — Local document scan failed

The local datanivra-agent scan produced no summary (for example a parser limit or a missing directory).

What to do: Run datanivra-agent documents scan --dry-run directly to see its reason code.

DOCUMENT_SCAN_OUTPUT_REFUSED — Scan output refused

The local scan output was not the expected aggregate shape (counts and codes only), so the CLI refused to print it (exit 5).

What to do: Use matching CLI and agent versions.

EVAL_SET_* — Eval-set bundle does not verify

datanivra eval-set verify or register found a mismatch (exit 32): EVAL_SET_CASES_DIGEST_MISMATCH, EVAL_SET_CASE_COUNT_MISMATCH, EVAL_SET_TAG_COUNTS_MISMATCH, EVAL_SET_SEED_MISMATCH, EVAL_SET_PLANTED_DIGEST_MISMATCH, EVAL_SET_DANGLING_EVIDENCE or EVAL_SET_MANIFEST_MISMATCH (differs from the registered manifest). Nothing was registered.

What to do: Regenerate the bundle with datanivra-agent eval-set generate using the registered seed and generation parameters.

Billing, plans and licences codes

BILLING_EVENT_NOT_READY — Billing event not ready

A billing provider event arrived before a related event it depends on, so it was not applied yet. Nothing was recorded; the provider delivers it again automatically.

What to do: Nothing to do: the plan updates once the provider retries. If Billing & Plan still looks wrong after an hour, contact support.

Operator runbook: docs/runbooks/billing-reconciliation.md

BILLING_NOT_CONFIGURED — Billing not configured

Online checkout, plan changes or the billing portal are not configured on this DataNivra deployment yet.

What to do: Nothing is wrong with your organization: your trial and data are unaffected. Upgrading becomes available once online checkout is enabled.

Operator runbook: docs/runbooks/stripe-keys-webhooks.md

BILLING_PROVIDER_ERROR — Billing provider unavailable

The call to the payment provider (for example to open checkout or the billing portal) failed or returned an unusable answer. No charge or plan change was made by this request.

What to do: Retry in a few minutes. If it persists, contact support with the correlation id.

Operator runbook: docs/runbooks/billing-reconciliation.md

BILLING_PROVIDER_UNKNOWN — Billing provider unknown

A billing webhook was sent to a provider address that this deployment does not have configured. This is a payment-provider callback, not a request you make.

What to do: Operators: check the webhook endpoint URL configured at the payment provider.

Operator runbook: docs/runbooks/stripe-keys-webhooks.md

COMMERCIAL_ERROR — Billing operation failed

A billing, plan or licence operation failed without a more specific code. Nothing was changed.

What to do: Retry. If it repeats, contact support with the correlation id.

COMMERCIAL_NOT_CONFIGURED — Plans or licensing not configured

A plan, licence or billing capability this request needs is not configured on this deployment (for example the licence file or deployment id of a self-hosted installation).

What to do: Self-hosted operators: install the licence file and set the deployment id, then restart. SaaS customers: contact support.

Operator runbook: docs/runbooks/enterprise-contracts.md

ENTITLEMENT_LIMIT_REACHED — Plan limit reached

Your plan's limit for this capacity (for example agents, sources or jobs) is reached; the error names the limit, never your usage numbers.

What to do: Upgrade in Billing & Plan, or free capacity (for example revoke unused agents).

Operator runbook: docs/runbooks/free-tier-and-trial.md

ENTITLEMENT_NOT_FOUND — No plan found

Your organization has no active plan and no default plan applies, so the request was refused (fail closed).

What to do: Contact support: every organization should at least have the Free plan.

Operator runbook: docs/runbooks/free-tier-and-trial.md

FEATURE_NOT_ENTITLED — Feature not in plan

Your plan does not include this feature (the error names the feature).

What to do: Upgrade the plan in Billing & Plan or ask your DataNivra contact; nothing was changed.

Operator runbook: docs/runbooks/free-tier-and-trial.md

FORBIDDEN — Forbidden

You do not have the permission this billing or plan operation needs (for example billing management).

What to do: Ask an administrator of your organization for the needed role.

Operator runbook: docs/runbooks/tenant-authorization-failure.md

IDEMPOTENCY_KEY_REUSED — Idempotency key reused

This Idempotency-Key was already used for a different billing or usage request.

What to do: Use a new key per distinct request.

INDUSTRY_PACK_NOT_ENTITLED — Industry pack not in plan

Your plan does not include this industry pack.

What to do: Move to a plan that includes the pack (Billing & Plan in the console) or ask your DataNivra contact.

Operator runbook: docs/runbooks/free-tier-and-trial.md

LICENSE_CLOCK_ROLLBACK — Licence clock moved backwards

The self-hosted installation's clock moved back past the last time the licence was checked (or the licence state file is missing or damaged), so licence validation fails closed.

What to do: Fix the host's time (NTP), restore the licence state file if it was removed, then restart. Contact support if the clock is correct.

Operator runbook: docs/runbooks/enterprise-contracts.md

LICENSE_DEPLOYMENT_MISMATCH — Licence for another deployment

The licence file is bound to a different deployment id than this installation.

What to do: Install the licence issued for this deployment, or ask DataNivra for one bound to its deployment id.

Operator runbook: docs/runbooks/enterprise-contracts.md

LICENSE_EXPIRED — Licence expired

The self-hosted licence expired and its offline grace period has ended.

What to do: Install the renewed licence file from DataNivra.

Operator runbook: docs/runbooks/enterprise-contracts.md

LICENSE_INVALID — Licence invalid

The licence file is malformed or not signed by a key this installation trusts.

What to do: Install the licence file exactly as delivered by DataNivra; do not edit it.

Operator runbook: docs/runbooks/enterprise-contracts.md

LICENSE_NOT_YET_VALID — Licence not valid yet

The licence's start date is still in the future.

What to do: Wait until the start date, or check the host's clock.

Operator runbook: docs/runbooks/enterprise-contracts.md

LICENSE_RENEWAL_REJECTED — Licence renewal rejected

The replacement licence names another licensee, or it neither renews nor extends the installed licence; the installed licence stays in place.

What to do: Check that you received the right file; ask DataNivra for a corrected renewal.

Operator runbook: docs/runbooks/enterprise-contracts.md

METERING_INPUT_REJECTED — Usage record refused

A usage record looked as if it could carry data values, so it was refused; usage records accept only counts, sizes and durations.

What to do: Nothing to do as a user; this indicates a product defect, so contact support with the correlation id.

PLAN_CATALOG_INVALID — Plan catalog invalid

The deployment's plan catalog configuration is invalid, so plan information cannot be served.

What to do: Contact support; operators correct the plan catalog configuration.

SUBSCRIPTION_NOT_FOUND — No subscription

There is no subscription to change, cancel or manage for your organization.

What to do: Choose a plan on Billing & Plan first.

SUBSCRIPTION_TRANSITION_INVALID — Subscription change not possible

The subscription cannot make the requested change from its current state. Details say why: `subscription=ALREADY_SUBSCRIBED` (you already have a paid plan; change it instead), `checkout=IN_PROGRESS` (a checkout for another plan was already completed and is being confirmed), or a change while a payment is due.

What to do: Refresh Billing & Plan. Pay any open invoice first; if a checkout is in progress, wait a few minutes for it to complete. Never pay twice: contact support if you think a second checkout went through.

Operator runbook: docs/runbooks/billing-reconciliation.md

TRIAL_ALREADY_CLAIMED — Trial already used

The free trial of paid features has already been used for this email address or work domain; each person or organization gets one.

What to do: Choose a paid plan in Billing & Plan, or continue on the Free plan.

Operator runbook: docs/runbooks/free-tier-and-trial.md

VALIDATION_FAILED — Validation failed

The billing or plan request is invalid; the details list the affected fields (never their values), for example a plan that is not self-service.

What to do: Correct the listed fields. For plans that are sold by contract, contact sales.

WEBHOOK_PAYLOAD_INVALID — Billing webhook not recognised

A verified payment-provider callback was not a recognised billing event. This is a provider callback, not a request you make.

What to do: Operators: check the webhook's event selection at the payment provider.

Operator runbook: docs/runbooks/stripe-keys-webhooks.md

WEBHOOK_SIGNATURE_INVALID — Billing webhook signature invalid

A payment-provider callback failed signature or timestamp verification and was ignored. This is a provider callback, not a request you make.

What to do: Operators: check the webhook signing secret reference and the server clock.

Operator runbook: docs/runbooks/stripe-keys-webhooks.md

Hosted sandbox codes

AGENT_EXITED — Sandbox agent stopped

The hosted sandbox's agent stopped before it became ready. The sandbox only uses synthetic data; none of your data is involved.

What to do: Reset the sandbox from the Sandbox page. If it fails again, contact support.

Operator runbook: docs/runbooks/sandbox-runner.md

AGENT_START_TIMEOUT — Sandbox did not start in time

The hosted sandbox's agent did not become ready within the start-up time limit.

What to do: Reset the sandbox from the Sandbox page; starting usually works on the next attempt.

Operator runbook: docs/runbooks/sandbox-runner.md

ESTATE_NOT_SYNTHETIC — Sandbox data refused

The sandbox's prepared demo estate was not marked as synthetic, so it was refused (the hosted sandbox only ever uses synthetic data).

What to do: Contact support; this is a product defect, not something you can change.

Operator runbook: docs/runbooks/sandbox-runner.md

PACK_HAS_NO_SANDBOX_ESTATE — Pack has no sandbox data

An industry pack chosen for the sandbox does not provide a synthetic sandbox estate.

What to do: Reset the sandbox and choose packs offered on the Sandbox page.

Operator runbook: docs/runbooks/sandbox-runner.md

PACK_NOT_INSTALLED — Pack not available in the sandbox

An industry pack chosen for the sandbox is not installed on the sandbox runner.

What to do: Reset the sandbox and choose packs offered on the Sandbox page; contact support if a listed pack fails.

Operator runbook: docs/runbooks/sandbox-runner.md

RUNNER_REPORT_REJECTED — Sandbox status refused

The control plane refused the sandbox runner's ready report, so the sandbox was stopped.

What to do: Reset the sandbox from the Sandbox page. If it fails again, contact support.

Operator runbook: docs/runbooks/sandbox-runner.md

SANDBOX_CONFINEMENT_UNAVAILABLE — Sandbox confinement unavailable

The hosted sandbox runner requires Landlock confinement for sandbox agents, but the host kernel does not provide it, so no sandbox agent was started.

What to do: Operator: run the runner on a kernel with Landlock enabled, or (owner decision) set DATANIVRA_SANDBOX_REQUIRE_CONFINEMENT=false.

SANDBOX_PREPARE_FAILED — Sandbox could not be prepared

The sandbox runner could not prepare the sandbox's synthetic data or files.

What to do: Reset the sandbox from the Sandbox page. If it fails again, contact support.

Operator runbook: docs/runbooks/sandbox-runner.md

Back to the support center · Open the troubleshooting guides

Still stuck? Contact support

Include the error code, the job, dataset or agent id and the time it happened. Never send credentials, enrollment tokens, secret values or source data — support never needs them.

Email support (support@datanivra.com)

Missing a capability rather than stuck on a problem? Request a feature.