US Brand Evidence Citation Table

Turn a small, buyer-owned evidence packet into a stable citation table for humans and machine-to-machine workflows. Submit normalized evidence rows and receive one deterministic JSON report, bounded Markdown citations, per-host and per-source counts, explicit limitations, and SHA-256 digests.

This Actor formats the evidence you provide. It does not browse, fetch, verify, rank, enrich, summarize, or infer facts. The facts, excerpts, and URLs are preserved in the JSON citation rows exactly after validation.

What you submit and receive

You submit 1–100 rows. Every row has:

• a unique opaque ASCII evidenceId;
• brandName, eventType, sourceName, and a bounded factual excerpt;
• observedAt in strict UTC format YYYY-MM-DDTHH:mm:ssZ;
• an HTTPS sourceUrl without credentials, fragments, unsafe schemes, or a port other than 443.

You receive exactly one useful report row in the Dataset containing:

• citations, sorted by observed UTC, brand, event, source, URL, and evidence ID;
• the original facts and URLs, with no external lookup;
• citationMarkdown, a bounded Markdown table;
• hostCounts and sourceCounts;
• fixed warnings that sources were not fetched or verified and excerpts were not interpreted;
• input, citation, count, Markdown, and result SHA-256 digests.

The successful terminal OUTPUT receipt is written only after the named result-found Dataset push is confirmed. Preflight, input, and report failures may write an error OUTPUT before any Dataset push. A delivery uncertainty is reported truthfully and the Actor never retries a possibly paid Dataset push.

Input

{
  "schemaVersion": "1.0",
  "rows": [
    {
      "evidenceId": "evidence-001",
      "brandName": "Northstar Coffee",
      "eventType": "price_change",
      "observedAt": "2026-07-31T09:30:00Z",
      "sourceName": "Buyer newsroom note",
      "sourceUrl": "https://example.com/northstar-price-note",
      "excerpt": "The buyer-supplied note says the seasonal blend price changed on July 31."
    }
  ]
}

Closed limits

The input is inline JSON only. The complete input is limited to 128 KiB UTF-8 and 100 rows. evidenceId is 1–64 ASCII characters. brandName and sourceName are 1–128 normalized characters. eventType is a 1–64 ASCII token. sourceUrl is 12–2,048 characters. excerpt is 1–2,000 normalized characters and at most 8 KiB UTF-8. Empty strings, leading/trailing whitespace, control characters, line breaks, duplicate IDs, invalid Gregorian dates, credentials, fragments, non-HTTPS schemes, and non-443 ports are rejected.

The public JSON schema rejects the expressible shape, length, whitespace, control-character, month/day, host, credential, fragment, scheme, and port errors before submission. Runtime validation remains the final gate for NFC normalization, exact leap-year/Gregorian validity, parsed URL authority semantics, duplicate IDs, and UTF-8 byte limits. Passing the form schema alone does not guarantee a paid report; the platform start event can already be charged before runtime rejects an invalid packet.

The report is limited to 64 KiB UTF-8 and its Markdown section to 48 KiB. A valid packet that cannot fit these output limits fails closed instead of returning a partial citation table.

Output and Dataset

The Dataset has one named result row. citations retains all seven input fields. hostCounts groups by the lower-case parsed URL hostname; sourceCounts groups by the exact source URL and includes that hostname. Counts are reconciled with totalRows, and all arrays are deterministically sorted.

No URL is opened. A valid URL means only that the submitted string passed the closed HTTPS syntax and safety rules; it is not evidence that the URL exists or supports the excerpt.

Pricing

Pay per event: one start charge plus one result-found charge only after one confirmed report Dataset write. The default Dataset event is not charged by this Actor. The run preflight requires a budget for both events and rejects an already-used result counter.

Tier	Discount	Start	Delivered result
FREE	0%	$0.00500	$0.01000
BRONZE	5%	$0.00475	$0.00950
SILVER	10%	$0.00450	$0.00900
GOLD	15%	$0.00425	$0.00850
PLATINUM	18%	$0.00410	$0.00820
DIAMOND	20%	$0.00400	$0.00800

Machine-to-machine use

The Actor is stateless, keyless, and suitable for an agent calling the Apify API or an Apify MCP server. A machine can prevalidate the public schema, send the same public-task-shaped JSON, let the Actor apply the stricter runtime gates above, read a successful single Dataset row, and verify resultDigest without a browser or a human login. The Actor never calls another Actor and never requires a proxy or BYOK key.

Related public Actors

These public Actors can supply adjacent buyer-owned evidence workflows. Links are recommendations only; this Actor does not call them.

Actor	Use it for
US Brand Signal Metrics Aggregator	Aggregate normalized signal rows before creating a citation packet.
US Brand Signal Brief Composer	Compose a bounded brief after the citation table has been checked by the buyer.
US Brand Action Queue	Turn selected, buyer-approved evidence into next-action rows.
US Brand Evidence Snapshot Diff	Compare two buyer-supplied evidence snapshots.
US Brand Offer Evidence Normalizer	Normalize offer evidence before citing it.

FAQ

Does it verify the source? No. It does not fetch URLs or make a claim that a source is real, current, or accurate.

Does it infer a brand or event? No. brandName, eventType, and the excerpt are buyer-provided and preserved.

Why must timestamps be UTC? A closed UTC form keeps sorting and digests reproducible across machines and time zones. Dates must also be valid in the Gregorian calendar, including leap years.

Can I use it from an AI agent? Yes. It is designed for schema-first API/MCP calls and returns a bounded single-row report with machine-verifiable digests.

Why did a valid-looking packet fail? It may exceed the input or output byte limits, contain a duplicate ID, an invalid date, unsafe URL syntax, or a field that is not normalized. The Actor does not truncate or return partial facts.

Why a citation table is a product, not cosmetic formatting

Evidence packets rarely fail because a team cannot draw a Markdown table. They fail because different contributors use different identifiers, timestamps, source labels, URL forms, row orders, and unstated assumptions. A pasted spreadsheet may look usable while remaining difficult to compare, hash, cache, hand to an API consumer, or audit after somebody sorts it differently.

This Actor provides one closed transformation boundary. It accepts a bounded packet, validates every field, applies a published canonical order, groups counts by exact source and normalized host, escapes Markdown cells, and calculates digests over the normalized input and each important output section. The same logical rows therefore produce the same report even when the caller submits them in a different order.

That reproducibility is useful, but it must not be confused with verification. The Actor cannot know whether the named brand is the intended legal entity, whether a publisher is authentic, whether an excerpt is accurate, whether a page changed after collection, or whether the caller has the right to reuse the text. Those gaps remain explicit in every delivered report.

Best-fit users

Marketing operations

Use the table to attach reviewed campaign, offer, launch, pricing, availability, or positioning observations to a brief. A stable evidenceId lets the brief, spreadsheet, Dataset row, and reviewer comments refer to the same observation without relying on row number.

Competitive-intelligence teams

Use it after an authorized collection and normalization step. The output gives analysts one reproducible citation appendix, source distribution counts, exact input and result digests, and an explicit instruction to open every source before consequential use.

Agencies and consultants

Use one run per client question, campaign review, or bounded evidence packet. The report can be exported as JSON for an internal system and as Markdown for a document. Separate packets keep client access boundaries and report digests meaningful.

Content and editorial teams

Use it to structure already-selected source excerpts before a writer prepares a draft. The Actor does not decide what is newsworthy, summarize a source, or approve a claim. Editorial review remains responsible for context, attribution, quotation rights, and accuracy.

Legal and compliance support

Use it only as an administrative evidence-indexing step under a qualified reviewer. The output is not an authentication record, legal conclusion, ownership finding, infringement assessment, admissibility opinion, or substitute for preserving the original material.

Data and automation teams

Use the closed JSON contract to stop malformed evidence at a known boundary. The result is deterministic and bounded, so an upstream test fixture and a downstream consumer can verify the same digests. safeToAutomate remains false because deterministic formatting does not make the underlying facts safe for automatic action.

Product boundary at a glance

The Actor does	The Actor does not
Validate one closed packet of 1–100 rows	Browse, scrape, fetch, render, or dereference a URL
Preserve the seven accepted fields	Rewrite, summarize, translate, classify, or infer an excerpt
Sort rows deterministically	Decide chronology, causation, importance, or truth
Count exact URLs and normalized hosts	Resolve publishers, organizations, domains, or brand ownership
Produce bounded JSON and Markdown	Store an unbounded archive or download source documents
Expose digests and a stable report identity	Authenticate screenshots, pages, documents, or signatures
Reconcile delivery and the named paid event	Estimate business impact, legal risk, or source credibility

Input contract in plain language

The top-level object accepts only schemaVersion and rows. Extra properties fail instead of being ignored. Each row accepts exactly seven properties.

Field	Required	Rule	Meaning
schemaVersion	yes	Exactly 1.0	Closed input contract version
rows	yes	1–100 rows; packet at most 128 KiB UTF-8	Evidence supplied for one report
evidenceId	yes	Unique 1–64 character ASCII token	Caller-controlled stable row identity
brandName	yes	1–128 normalized characters	Display label supplied by the caller, not resolved identity
eventType	yes	1–64 character ASCII token	Caller-defined event category
observedAt	yes	Strict valid Gregorian UTC second	When the caller says it observed the evidence
sourceName	yes	1–128 normalized characters	Caller-supplied source label
sourceUrl	yes	Credential-free HTTPS, port 443 only, no fragment	Citation value preserved but never opened
excerpt	yes	1–2,000 characters and at most 8 KiB	Caller-supplied factual text preserved without interpretation

observedAt is not publication time unless the upstream process deliberately made it so. It is not automatically the time a page changed, an offer became effective, or a claim became true. Choose and document that mapping upstream.

Do not put API keys, signed private links, usernames, passwords, cookies, access tokens, or personal data that is unnecessary for the review purpose into any field. URLs with embedded credentials are rejected, but the caller remains responsible for the content of an otherwise valid URL and excerpt.

Canonicalization and stable identity

Rows are ordered by:

1. observedAt;
2. brandName;
3. eventType;
4. sourceName;
5. sourceUrl;
6. evidenceId.

Object keys are canonicalized before hashing. The report identity is derived from the canonical input digest rather than a random UUID or current clock. Reordering equivalent rows therefore does not create a different logical report.

The stable entityId is useful for caching, deduplicating a review attachment, or confirming that a UI and API consumer refer to the same logical packet. It is not a resolved identifier for a company, trademark, product, publisher, or person.

Decision layer

The report adds a compact decision envelope around the original citation product.

Field	How to read it
status	success means the complete accepted packet was transformed and delivered
recordType	Stable row type evidence_citation_table
decisionSchemaVersion	Version of the additive decision contract
entityId	Digest-derived identity of the logical packet
observedAt	Latest buyer-supplied observation timestamp in the packet
freshness	Explicitly unavailable; the source was not fetched and no current clock was read
change	Explicitly unavailable; no previous run or source state was loaded
confidenceScore	Confidence in transformation integrity only
confidenceBasis	Published boundary for that narrow score
sourceEvidence	Counts and digests pointing to the included citations without duplicating them
dataGaps	Source, identity, rights, truth, freshness, and interpretation boundaries
negativeSignals	Machine-readable no-fetch, no-verification, and no-identity warnings
recommendedAction	Open every cited source and obtain qualified review
priority	Review priority, not a legal, reputation, or financial risk score
safeToAutomate	Always false for consequential action
summary	Count-based description with the no-verification boundary
partial	false when all accepted rows are included; it does not mean sources were verified
failureDiagnostics	null on a delivered report; terminal failures are in KVS OUTPUT
billing	Exact delivered unit and named event

The confidence value is intentionally narrow. A high value means the Actor is confident that it applied its deterministic validation, ordering, escaping, counting, and hashing contract. It does not mean a source is credible, a fact is true, the brand is correctly identified, the packet is current, or a legal claim is strong.

Citation, source, and host sections

citations preserves every accepted row. sourceCounts groups by the exact URL string, while hostCounts groups by the lower-case hostname parsed from that URL. Two different paths on the same host are therefore two exact sources but one host.

The counts answer structural questions only:

• how many submitted rows were accepted;
• how many exact URL values appear;
• how many normalized hostnames those values use;
• how many rows cite each exact URL and host.

They do not measure source diversity in an editorial sense. Multiple URLs on one publisher may repeat the same underlying information; two hosts may belong to one organization; a mirrored page may not be independent corroboration. A reviewer must make those judgments.

Markdown safety and limitations

The Markdown table escapes backslashes before pipes so submitted text cannot silently add a column. Control characters and line breaks are rejected at validation. The final Markdown section is capped at 48 KiB and the complete report at 64 KiB.

Markdown is a convenience representation, not a security or rendering sandbox. A downstream system should still treat every cell as untrusted data, follow its own HTML sanitization policy, and avoid automatically opening submitted links.

Digests and reproducibility

The report contains:

• inputDigest for canonical normalized input;
• citationsDigest for the sorted citation rows;
• hostCountsDigest for normalized host counts;
• sourceCountsDigest for exact source counts;
• markdownDigest for the Markdown bytes;
• resultDigest for the complete report body before that final digest is attached.

Use digests to detect a changed packet between workflow stages, key an internal cache, reconcile an exported attachment, or confirm that two systems processed the same canonical bytes. Do not use a digest as proof of authorship, source authenticity, timestamp accuracy, copyright ownership, or fact truth. It proves consistency of the bytes handled by this Actor.

KVS OUTPUT reconciliation

The terminal OUTPUT object preserves the existing status, report, delivery, and terminal sections and adds a run-level run receipt.

Run field	Meaning
input.requestedCount	Number of submitted array rows visible to the bounded counter
input.uniqueCount	Number of syntactically valid unique evidence IDs visible before full validation
input.duplicateCount	Repeated valid evidence IDs detected in the submitted packet
input.invalidCount	Rows without a syntactically valid evidence ID
attemptedCount / unattemptedCount	Evidence rows entering the successful report transform versus withheld before it
successfulCount / failedCount	Row-level success or terminal failure accounting
deliveredRowCount	Confirmed Dataset report rows; maximum one
paidRowCount	Confirmed delivered Dataset report rows with at least one result-found event; maximum one
freeRowCount	Confirmed delivered Dataset report rows with zero result-found events; maximum one
anomalousChargeCount	Confirmed result-event increments beyond the single expected paid report row
withheldRowCount	A built report not confirmed as delivered
partial	True for terminal or delivery error receipts
budgetStopped	True only when the buyer cap cannot cover the bounded paid result
fatalError	Stable terminal code, otherwise null
ambiguousDeliveryCount	One when Dataset delivery cannot be proven absent or confirmed
replaySafe	False after confirmed or ambiguous delivery; inspect before retrying
safeToAutomate	Always false for consequential follow-up

On success, the Actor performs exactly one named Dataset push, verifies that the custom result counter increased by one, writes the terminal receipt, and exits. It never retries a possibly paid Dataset push. If delivery is ambiguous, inspect the run Dataset and charge events before deciding whether another run is appropriate.

Failure catalogue

Code	Stage	Safe response
invalid_input	Input read failed	Correct the submitted object; no report was delivered
invalid_input_shape	Top-level shape is not closed	Submit only schemaVersion and rows
invalid_schema_version	Version is not 1.0	Migrate the caller explicitly
input_too_large	Packet exceeds 128 KiB	Split it into separate meaningful packets
invalid_row_count	Fewer than 1 or more than 100 rows	Use the documented bound
invalid_row_shape	A row has missing or extra fields	Map exactly the seven accepted fields
duplicate_evidence_id	Two rows share an ID	Fix identity upstream; do not silently renumber
invalid_observed_at	Timestamp form or calendar date is invalid	Send a real UTC second
invalid_source_url	URL fails the closed HTTPS rules	Remove credentials/fragments or correct the URL
invalid_excerpt	Text is empty, unnormalized, unsafe, or too large	Normalize and reduce the caller-owned excerpt
output_too_large	A valid input cannot fit the report bounds	Split the packet; the Actor does not truncate
pricing_misconfigured	Deployed PPE contract is not recognized	Stop and inspect Actor pricing
budget_read_failed	The charging manager cannot prove cap or spend	Stop before delivery; inspect platform billing state
budget_limit	Buyer cap cannot cover start plus one result	Increase the cap deliberately or do not run
delivery_unknown	Dataset push or result counter is ambiguous	Inspect Dataset and charged events before retry
result_uncharged	Delivery occurred without the required result delta	Treat the run as failed and inspect billing
result_charge_delta	Result counter changed by more than one	Treat as a billing-integrity failure
output_write_failed_after_delivery	Paid report delivered but success receipt write failed	Do not rerun blindly; inspect the Dataset
exit_failed_after_delivery	Delivery and receipt completed but terminal exit failed	Use the delivered evidence and inspect run state

Failures never create a free Dataset citation table. A KVS error object is operational evidence, not a product result.

REST API example

Use an Apify API token through your secret manager. Do not place a real token in source code or the Actor input.

curl -X POST \
  "https://api.apify.com/v2/acts/zinin~us-brand-evidence-citation-table/runs?token=$APIFY_TOKEN&waitForFinish=90" \
  -H "Content-Type: application/json" \
  --data '{
    "schemaVersion": "1.0",
    "rows": [{
      "evidenceId": "evidence-001",
      "brandName": "Northstar Coffee",
      "eventType": "price_change",
      "observedAt": "2026-07-31T09:30:00Z",
      "sourceName": "Buyer newsroom note",
      "sourceUrl": "https://example.com/northstar-price-note",
      "excerpt": "The buyer-supplied note says the seasonal blend price changed on July 31."
    }]
  }'

Read the run’s default Dataset for the one report row and the default Key-Value Store record OUTPUT for terminal reconciliation. Do not infer success from HTTP submission alone.

JavaScript client pattern

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('zinin/us-brand-evidence-citation-table').call({
  schemaVersion: '1.0',
  rows: evidenceRows,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const output = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('OUTPUT');

if (output?.value?.status !== 'success' || output.value.run?.status !== 'COMPLETE') {
  throw new Error(`citation table failed: ${output?.value?.code ?? 'unknown'}`);
}
if (items.length !== 1 || items[0].resultDigest !== output.value.report.resultDigest) {
  throw new Error('Dataset and OUTPUT do not reconcile');
}

The code deliberately checks both storage surfaces. A finished run without a successful terminal receipt is not accepted as a delivered report.

Python client pattern

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('zinin/us-brand-evidence-citation-table').call(run_input={
    'schemaVersion': '1.0',
    'rows': evidence_rows,
})

items = list(client.dataset(run['defaultDatasetId']).list_items().items)
output = client.key_value_store(run['defaultKeyValueStoreId']).get_record('OUTPUT')['value']

assert output['status'] == 'success'
assert output['run']['status'] == 'COMPLETE'
assert len(items) == 1
assert items[0]['resultDigest'] == output['report']['resultDigest']

Store the token in an environment variable or managed secret. The Actor itself needs no third-party credential.

No-code and webhook pattern

An Apify Task can hold a reviewed template packet, but static evidence becomes stale. Prefer a workflow that creates a fresh bounded input, assigns durable evidence IDs, runs the Actor, waits for terminal state, reads both Dataset and OUTPUT, and sends the report to a human review queue.

If a webhook consumer receives only the run ID, it should fetch the terminal receipt before processing the Dataset. Route FAILED and AMBIGUOUS receipts to operations. Never trigger publication, enforcement, outreach, pricing changes, or legal notices from the report alone.

Agent and MCP pattern

An agent can call the Actor as a deterministic formatting tool after it has assembled a caller-authorized evidence packet. The agent should retain these rules in its policy:

1. never claim that the Actor opened or verified a source;
2. never replace stable evidence IDs merely because rows were reordered;
3. surface dataGaps, negativeSignals, and safeToAutomate with the table;
4. compare Dataset and KVS digests before accepting delivery;
5. send the result to a person before consequential use;
6. inspect ambiguous billing/delivery before retrying.

The Actor is not a research agent, browser, fact checker, retrieval system, or legal reasoning tool.

Cost planning

One successful run creates one result event whether the packet contains 1 or 100 accepted rows. The cheapest configured tier is therefore the published start price plus the published result price for one bounded report. Actual deployed pricing displayed by Apify is authoritative.

Do not combine unrelated clients, matters, brands, or review questions merely to reduce event count. A report digest is most useful when the packet has one coherent review boundary. Separate runs also make retention, access control, deletion, and reviewer assignment easier.

The Actor performs no external HTTP request, proxy call, LLM inference, child Actor run, or paid data-source lookup. Variable runtime cost is therefore limited to the bounded Apify execution and storage path, but account compute and storage charges remain governed by the buyer’s Apify plan.

Privacy and retention

The Actor writes the accepted report to the default Dataset and the terminal receipt to the default Key-Value Store. Those storages may contain brand labels, source URLs, and excerpts supplied by the caller. Use the minimum necessary data, configure access and retention for the organization’s purpose, and remove exports and run storage according to policy.

The Actor is stateless across runs and does not read prior Datasets, Key-Value Stores, cookies, browser profiles, contact lists, or user accounts. It does not send data to an LLM or external enrichment provider. Apify’s platform storage remains an external processing boundary controlled through the run and account settings.

Avoid personal data unless it is necessary, lawful, and covered by the caller’s process. A public URL does not automatically make every person, excerpt, or downstream use unrestricted.

Source rights and lawful use

The caller owns collection, provenance, permissions, and the decision to submit each excerpt. This Actor does not collect the underlying page and cannot determine whether quotation, redistribution, monitoring, or processing is authorized.

Before use, confirm:

• the collection method was authorized and compatible with applicable terms;
• the submitted excerpt is no longer than necessary for the review purpose;
• copyright, database, confidentiality, and privacy obligations are respected;
• the named brand or entity has been resolved by an appropriate process;
• the source is authentic and the cited page supports the submitted text;
• retention and access controls match the client or matter;
• a qualified reviewer approves any consequential conclusion.

The output is a structured index of buyer-supplied assertions. It is not legal advice and does not establish permission, ownership, infringement, liability, deception, endorsement, or evidentiary admissibility.

Quality checklist before accepting a report

• Confirm status == "success" in OUTPUT.
• Confirm run.status == "COMPLETE" and run.partial == false.
• Confirm exactly one Dataset row and one paid result event.
• Compare Dataset resultDigest with OUTPUT.report.resultDigest.
• Confirm input.requestedCount, uniqueCount, and successfulCount reconcile.
• Confirm deliveredRowCount == 1 and paidRowCount == 1.
• Preserve dataGaps, negativeSignals, and the confidence boundary in downstream displays.
• Open every cited source and verify the excerpt, context, publisher, date, and identity.
• Confirm the caller has the right and lawful purpose to use the evidence.
• Obtain qualified review before publication, outreach, enforcement, or another consequential action.

Common mistakes

Treating a valid HTTPS string as a verified page. URL validation prevents several unsafe forms; it does not prove that the page exists, is public, is authentic, or contains the excerpt.

Treating the latest observedAt as live freshness. It is the latest timestamp supplied in this packet. The Actor never reads the current clock or source state.

Using confidenceScore as fact probability. It measures deterministic transformation integrity only. Keep confidenceBasis beside it.

Assuming multiple hosts are independent corroboration. Host counts are structural. Ownership, syndication, mirrors, and common sourcing are not resolved.

Changing IDs on every run. Stable IDs make review comments, diffs, and evidence references durable. Change an ID only when the caller’s identity policy says it is a different observation.

Packing unrelated work into one report. It makes the digest, retention boundary, and reviewer responsibility less meaningful.

Retrying an ambiguous delivery automatically. A Dataset write may have succeeded even when the client did not receive confirmation. Inspect the run first.

Publishing the Markdown without review. The table preserves caller-supplied text and links. It does not approve wording, rights, safety, context, or claims.

Extended FAQ

Does it browse the submitted URLs? No. There is no browser, fetch call, proxy, resolver, or child Actor in the runtime.

Does it check whether two URLs are duplicates? It counts exact URL strings and normalized hosts. It does not canonicalize tracking parameters, redirects, mirrored pages, or semantic duplicates.

Does it merge repeated facts? No. Rows are preserved and sorted. Only duplicate evidenceId values are rejected.

Can a source URL contain a fragment? No. Fragments are rejected to keep the closed citation contract consistent.

Can I use HTTP instead of HTTPS? No. The accepted contract requires HTTPS and rejects non-443 ports.

Can the Actor infer eventType? No. It validates the caller’s token but does not classify the evidence.

Can it summarize long pages? No. Submit a bounded, authorized excerpt selected by your upstream process.

Why is partial false if sources are unverified? partial describes completeness of the deterministic transform: every accepted row is present. Verification gaps are separately explicit in dataGaps, negativeSignals, freshness, and safeToAutomate.

Why is replay safety false after success? A new run would create another paid report. The result is deterministic, but billing and storage side effects are not a free idempotent replay.

Can it compare two citation packets? Not in this Actor. Use a dedicated snapshot-diff product after both packets have stable identities and reviewed boundaries.

Can it prove a screenshot or PDF was authentic? No. It accepts text and HTTPS citation values only and never opens the source asset.

Is the report legal evidence? It is a deterministic data artifact. Authentication, preservation, admissibility, legal meaning, and qualified advice are outside its scope.

Can it run on a schedule? Technically yes, but a static buyer-supplied packet does not become fresh by being rerun. Schedule the authorized upstream collection and submit a new packet only when there is genuinely new reviewed evidence.

What should a downstream UI show first? Show the summary, citation rows, source links, data gaps, negative signals, review action, and safeToAutomate=false. Do not lead with the confidence number alone.

Built by Zinin for bounded, auditable evidence workflows.