What this build does not protect against.
Each entry opens with what could go wrong and what to do about it. Then it says what the limitation is, what it doesn’t affect, what limits the damage today, and what would close it. Where an entry has earlier findings that are now fixed, a closing list gives each one with the date it was fixed. Each entry has a “Last changed” date: the date the entry was last updated in what it says. A change of wording alone does not move it. It can differ from dates in the entry’s text, which say when the product changed. Entries are ordered by what a security reviewer should read first, not by the severity of the underlying mechanism.
Current as of 16 November 2026. Most items are known boundaries rather than defects, and most are deliberate scope decisions for this version. Entries 22 to 27, 31, 32 and 38 are defects, listed until they are fixed. Entries 21, 28 and 34 are fixed, and stay here, marked fixed, so that what each said and what replaced it can both be read. Entry 16 is a known defect whose fix is deferred until after the shadow pilots start.
One further finding is held back, pending disclosure to the upstream projects it affects. It is not in SignetGate’s own code. It will be published here once the affected releases are fixed, or as the upstream projects’ disclosure policies allow.
Two entries are launch blockers: entries 1 and 2. A launch blocker must close before this build is used beyond a scoped pilot, and neither is closed. A scoped pilot is one where the exposure is bounded: shadow mode, where the gated tool records an approval but moves no money; a test account; or a payment ceiling, enforced by the customer’s own payment system, low enough that the exposure is acceptable to them. Everything else on this list is a maturity question rather than a bar.
1. The reviewer credential model is a development stand-in
Last changed: 6 November 2026.
Anyone who knows a reviewer account’s password can sign in as that reviewer. So a receipt shows which account approved a payment, but not which person. This is the first of the two launch blockers: outside a scoped pilot, keep it away from real payment rails until single sign-on with enforced multi-factor authentication is in place.
What it is. A reviewer signs in with an account id and a password, set when the server is deployed. The server stores the password hashed with scrypt and exchanges it for a signed session cookie that lasts 12 hours. That session is the only source of the reviewer account bound into every receipt, and the server never reads the account from a request. There is no second factor, no device binding, and no way to tell one human from another beyond knowledge of a shared secret.
This matters more here than in most systems. One of the four adversaries this design addresses is the insider reviewer, who approves a payment to their own account and later denies it. A credential that cannot tell two people apart is the credential that threat needs.
What it doesn’t affect. The receipt itself. Signatures, hashing and the duty-of-care checks are unaffected, and a receipt still proves that some holder of that credential approved that payment. What it cannot prove is which person did.
What limits the damage today. Sign-in attempts are throttled, and the lockout survives a restart. Unknown and disabled account ids are throttled the same way, and a wrong password costs them the same password hash as a real id, checked against a decoy. So sign-in reveals which ids exist neither by its count of attempts nor by its timing. The server enforces the session’s 12-hour lifetime inside the signed token, not through the cookie’s own expiry setting.
Four further controls narrow this risk, and none of them closes it:
- Sessions can be ended. Sign-out revokes the session on the server rather than asking the browser to drop a cookie, and one operator command ends every session a person holds, including on devices nobody listed. That covers a person who has left. A reviewer or an agent key removed from the configuration is disabled at the next start, and the reviewer’s sessions end. An agent key can be revoked with a command. Every route that takes a session, receipts and certificates included, refuses one whose account is no longer enabled. An open event stream ends at once on sign-out. A revocation from the command line is not instant: the stream ends at its next event or keepalive, so within 15 seconds.
- The receipt says how the account signed in. It carries
assurance: SHARED_SECRET, so the evidence itself states the weakness, rather than a document nobody attaches to it. The certificate a firm hands to a bank reads “a username and password (no second factor; identifies a login, not a person)”. - The receipt’s
verifierAuthenticatedcheck fails when an ELEVATED item is decided more than four hours after the last sign-in, which is the “logged in this morning, approved a wire at five” case. The server refuses that approval until the reviewer signs in again, so the check reads false only on a refusal. - Production refuses to boot on shared passwords unless the operator records, in configuration, that they accept this specific risk. So the server enforces the launch blocker, not this page.
None of that addresses a shared or stolen password, which is the risk itself.
What would close it. SSO with enforced MFA for the session, and a per-decision WebAuthn
assertion on ELEVATED items. They work at different layers and are not alternatives. SSO gives
a firm the lifecycle control a compliance function actually asks for. It does not answer the
insider threat, because the identity provider’s record of MFA (amr: ["mfa"]) can describe a
login seven hours before the approval. The assertion does answer it, because a key that
cannot be copied signed that payment.
Outside a scoped pilot, do not deploy against real payment rails until at least the first exists. The scoped pilot is a deliberate exception. A pilot starts only once the operator has recorded, in configuration, that they accept this risk. The first pilots run in shadow mode; pilots on a test account or under a low ceiling come later. That recorded acceptance replaces neither closure. The exception has a cost. A ceiling-capped pilot moves real money, under a limit the customer’s own payment system enforces, and every receipt it produces names a credential rather than a person.
Earlier findings, now fixed.
- 5 September 2026: the
verifierAuthenticatedcheck could never fail. It only tested that an account id was present on a session the server had already validated, so every receipt asserted it. Fixed. - 16 September 2026: when the four-hour check was first built, a failure was only recorded, and the approval went through (entry 13). Fixed.
- 29 September 2026: an unknown account id answered sign-in in about a sixth of the time a real one took, so the timing revealed which ids exist. Fixed.
- 29 September 2026: removing a reviewer or an agent key from the configuration did nothing. Our pre-launch testing on 28 September 2026 measured a removed reviewer signing in again and approving a payment. Fixed.
- 2 October 2026: an open queue stream checked its session only when it opened, so it went on delivering new payments after sign-out or revocation. Our pre-launch testing on 1 October 2026 found it. Fixed.
2. Only the server, not the reviewer’s own machine, binds what is shown to what is signed
Last changed: 16 November 2026.
The receipt’s fingerprint of the payment is computed by our server, and nothing on the reviewer’s machine checks that the payment on screen is the one it describes. This is the second of the two launch blockers, and it sits under the product’s central claim. To check a receipt without relying on our server, use the offline checker with a payment instruction and a key your firm kept itself. Where you can, supply invoice data from your finance system rather than data that mirrors the payment; it is what makes a look-alike name visible (see below).
What it is. The receipt binds payloadHash, a hash the server computes when the payment
arrives. What ties that hash to what the console showed is the server’s own derivation, and
nothing the reviewer’s machine does. The console never reads payloadHash: it does not
recompute it and does not compare it. So verifying the receipt’s signature proves the server’s
claim about a hash, never that the hash describes what was displayed. That gap is what keeps
this entry open.
Characters that hash faithfully but display deceptively are refused in the vendor name and the invoice number:
- every control, format, surrogate, private-use and unassigned character, which includes zero-width spaces and bidirectional overrides;
- separators other than a plain space, such as U+00A0;
- from 30 September 2026, characters Unicode says to display as nothing, some of which are letters or marks, such as U+3164 HANGUL FILLER, which the rule otherwise admitted;
- from 30 September 2026, a leading or trailing space, and two spaces in a row, which a browser shows as none and as one;
- from 2 October 2026, text not in Unicode normalisation form C. An accent written as a letter followed by a combining mark looks exactly like the single-character accent, and hashes differently.
The invoice number is generated by machine and compared exactly, so it takes a tighter rule. It admits only unaccented letters, digits, the space, the full stop, the underscore, the slash and the hyphen.
What still gets through is homoglyphs: letters from another script that look the same, such as
a Cyrillic о in a Latin name. A vendor name has to accept any Unicode letter to be
usable at all.
What it doesn’t affect. The receipt, which stays sound evidence. A receipt still proves that some holder of a reviewer credential approved that payment, and anyone can reproduce the payment’s hash. Given a payment instruction beside a receipt, the offline checker settles whether the record is about that payment. What is unproven is the step before: that the payment the hash names is the one shown to the person who approved it. That link runs on the server only.
What limits the damage today.
- The comparison table is derived from the signed payment each time it is read, by one shared implementation that both the server and the review screen use. No second stored copy is read.
- A test checks the whole chain rather than each end. It builds a payment, hashes it, renders the review screen and checks the displayed text against the hashed bytes. A one-character change proves the check can fail.
- The server refuses rather than shows when a stored payment no longer matches its stored hash, on the review screen and again before it produces a certificate.
- The certificate prints the stored value, or nothing. It is refused
(
409 CERTIFICATE_UNAVAILABLE, naming the field) when any value it would print has a character outside its standard font’s set, which is Windows-1252. The cost is that a payee or refusal reason in Polish, Greek, Cyrillic, CJK or any other script outside it gets no certificate. The receipt is unaffected, and the offline checker and the console read it as before. - The certificate marks what the signature does not cover. It prints the risk tier and its reasons, and the simulated CoP result, under “Not covered by the signature” rather than among the signed values. The receipt still does not carry them.
- The character rules above apply to the payment and to the invoice data alike. They refuse characters that display invisibly or reorder the text around them, and spaces a browser would not show as they are. The comparison table also enforces that its two columns line up position by position, rather than assuming it.
- Risk scoring has always run on the server over the payment, so none of this ever let a payment skip the risk tiers. The sort code and account number accept only digits in a fixed pattern, so the two fields that move the money never accepted such characters.
- The repeated-payment check compares the payment, not only its bytes. A variant the character rules cannot catch, such as a changed separator in an invoice number, is still matched to the earlier decision. It compares vendor names with accents folded, so the two spellings of an accented name are matched too.
Homoglyphs stay unmitigated. A Cyrillic о in a Latin vendor name is a letter, so the
character rules accept it on purpose, and it looks the same as the Latin o. Refusing it would
refuse a legitimate non-Latin supplier name billing a UK firm: a control failing on real input.
What limits a homoglyph depends on where the invoice data came from:
- With independent invoice data, which keeps the finance system’s name, the simulated CoP
compares the agent’s name with that one. A homoglyph gives
NO_MATCHand a vendor-name mismatch, and the payment is elevated. - With invoice data that mirrors the payment, as an agent supplies it, the CoP compares the
name with itself and gives
EXACT_MATCH, and every row of the comparison matches. The payee fingerprint changes, so the payment is elevated as a new payee, but only until a payment to that payee has been approved (entry 20; until 14 October 2026, one attempt of any kind was enough). - In both, a refusal that judges the payee is remembered by its account, from 5 October 2026.
A payment to an account the same agent had refused that way in the look-back window is
flagged
PAYLOAD_PREVIOUSLY_REJECTEDand elevated, whatever its name, and the reviewer is shown the earlier refusal. Entry 16 says which refusals count and what the check does not reach. - A refusal that does not judge the payee is remembered only for the same payment, from
6 October 2026. That covers the system’s own refusals (
CHALLENGE_FAILED,CHALLENGE_UNVERIFIABLE), and a reviewer’s refusal because the document was missing or unreadable or the payment had already been made, or, from 14 October 2026, because the payment is held to confirm with the supplier. After one of those, a look-alike name is not flagged by the earlier refusal.
So the homoglyph that remains unmitigated is a payee no one has refused for a reason about the
payee. With mirrored invoice data it reaches the reviewer looking like the real name, and once
seen, as STANDARD work.
What would close it. The console recomputing payloadHash from the payment it displays,
and refusing to arm approval unless it matches the hash the receipt will carry. The console
would also send that hash with the decision, so the server refuses to sign unless it matches
the payment it is about to sign. Both halves are needed. The first catches a screen that
disagrees with the payment. The second catches a console that displays one payment and
approves another, which is the same divergence one step further along.
That check would run in code our server serves, so it covers divergence between what is displayed and what is signed. It does not cover a modified client or a compromised server. For those, the answer stays what it is today: the offline checker, after the fact, against a payment instruction and a key the firm kept itself.
For homoglyphs, what would close it is a confusables check (Unicode TR39) when the payment arrives, shown to the reviewer as a risk reason rather than used to reject.
The payee-name collision is the narrower problem next door (entry 12).
Earlier findings, now fixed.
- 16 September 2026: characters that hash faithfully but display deceptively, such as zero-width spaces and bidirectional overrides, reached both the hash and the screen unfiltered. Fixed.
- 16 September 2026: the review screen showed a second stored copy of the five payment fields, computed when the payment arrived, while the signature covered the payment itself. Nothing but one write having stored both tied them together. Fixed.
- 16 September 2026: no test followed a payment from its hash to the screen. Both ends were well tested on their own, which is why the gap between them went unnoticed. Fixed.
- 30 September 2026: a refused payment resubmitted with a character that displays as nothing, or with a leading, trailing or doubled space, came back without its refusal flag. Fixed.
- 2 October 2026: a refused payment resubmitted with an accent written as a letter and a combining mark came back unflagged and, once its payee had been seen, as ordinary work. Our pre-launch testing on 1 October 2026 found it. Fixed.
- 2 October 2026: a vendor name outside the certificate’s standard font printed as other text.
Our pre-launch testing on 1 October 2026 printed a name of CJK letters as
Acme Supplies Ltd, under the note saying the values were checked against the signature. Fixed: the certificate is refused instead. - 5 October 2026: a refused payment that came back under a look-alike name, to the same account, was not flagged as previously refused. Our pre-launch testing on 4 October 2026 identified the case; we measured it on 5 October 2026. Fixed for refusals that judge the payee, which are now remembered by their account.
3. Rendering deception is unmitigated
Last changed: 1 November 2026.
A PDF can be made to show one account number while hiding another in its text, and nothing in this version detects that. The comparison table catches it only where the invoice data comes from your finance system and the payment from what the agent passed to the payment tool, so supply the invoice data from there (entry 35).
What it is. The console asks a person to read digits off a rendered PDF. A document crafted to display one account number while its text layer encodes another, or to render differently at different zoom levels, defeats that, and nothing in this version detects it. The typed challenge is the most exposed part, because it exists to make the reviewer read the rendered document.
What it doesn’t affect. The reviewer’s session. The PDF parser runs in a sandboxed frame with an opaque origin and cannot reach the session, so a malicious parser is contained. That holds however the page is opened: it sets its own sandbox, and only the console may frame it. The risk here is a document that parses correctly and lies.
What limits the damage today. For the five compared fields, the comparison against the
invoice data the customer supplies catches a mismatch, but only where that data comes from the
finance system (STRUCTURED_FEED; see entry 4) and the payment from the agent’s own tool
arguments (entry 35). The console labels which source it is comparing against.
What would close it. Comparing the rendered image against the extracted text layer, or requiring a structured feed for high-value payments. This version does neither.
Earlier findings, now fixed.
- 2 October 2026: another site could frame the page that parses the PDF outside its sandbox. Our pre-launch testing on 1 October 2026 found it. Fixed.
4. OCR-sourced ground truth is not independent of the document it is compared against
Last changed: 1 November 2026.
Where the invoice data is read by OCR from the agent’s own PDF, a doctored invoice changes both sides of the comparison together, and the table agrees with itself while being wrong. Supply the invoice data from your finance system wherever you can, and treat a comparison against OCR as a weaker check.
What it is. The comparison table is the defence against a fraudulent payee paired with a
matching doctored invoice. It works because its two columns are independent witnesses. With
invoice data from the finance system (STRUCTURED_FEED) they are, because the finance system
never saw the agent’s PDF. With OCR they are not. The invoice data is read out of the
same attacker-supplied document, so a doctored invoice moves both columns together, and the
comparison agrees with itself while being wholly wrong.
What it doesn’t affect. The comparison against a structured feed, where the payment is built from the agent’s own tool arguments (entry 35). There the defence is real, and it is the product’s main answer to a compromised agent.
What limits the damage today. The console shows the source, and the wording differs
materially: “compared against your finance system” versus “compared against OCR of this
same document”. Low-confidence OCR raises GROUND_TRUTH_LOW_CONFIDENCE and forces ELEVATED.
A CHALLENGE_FAILED refusal on OCR-sourced invoice data is left out of reviewer metrics,
because a mismatch there can mean the document deceived the reviewer rather than that they
were careless. Our public description of the comparison says it is a real defence only where
the invoice data comes from the finance system: see the threat model in
the security policy.
What would close it. Requiring a structured feed above a value threshold. That is a policy decision, not a technical one.
5. The render-failure signal is client-reported and can be suppressed
Last changed: 4 September 2026.
The check that a document rendered cleanly runs in the reviewer’s browser. A modified console could hide a genuine rendering problem and let approval go ahead over a damaged or substituted render. That needs someone able to modify the console. So limit who can run or modify the review console, and watch the rate and kind of rendering failures in the reviewer metrics.
What it is. The console treats any warning from the PDF renderer during load or render as
a render failure: approval stays unarmed, and the typed challenge answers
CHALLENGE_UNVERIFIABLE. That detection happens in the browser. A modified client that leaves
out a genuine warning arms approval over a degraded or substituted render.
What it doesn’t affect. A client that falsely claims a failure. That only blocks its own approval, which is harmless. Only leaving a warning out fails open.
What limits the damage today. It needs a modified client, so it is an insider risk rather than one the agent can cause. The warnings are sorted into kinds that separate structural recovery from substitution, and the reviewer metrics report the rate and the kind. So a systematic class of documents can be told apart from a one-off.
What would close it. Rendering the captured document on the server when the payment
arrives, and recording whether the renderer warned. The bytes are already stored under their
hash, and already read once to confirm the file type (magic-byte sniffing), so the extra cost
is a headless render. We treat this as the completion of the render check rather than a
general roadmap item. Until it exists the finding is provisional by construction. Unlike
serverDwellMs, there is no server-side measurement of the same quantity to fall back on.
6. Shadow detection cannot see settings-file allow rules
Last changed: 28 October 2026.
The SDK refuses to start on a configuration that says a gated tool needs no approval, but it cannot see every such setting. Allow rules in the Claude Code settings files, and an integration that never uses the SDK’s setup, are invisible to it, so check both when you review an integration.
What it is. The SDK refuses to start when a gated tool is in allowedTools or the
permission mode is bypassPermissions. It cannot see allow rules in the Claude Code settings files,
which upstream documents explicitly. It also cannot see an integration that never uses the
SDK’s setup at all.
The start-up check has the same edge. It reads the options it is given and the settings files
they name, and nothing else. Since 23 October 2026 it refuses to start unless settingSources is
[] and strictMcpConfig is true; what each option does is in the Agent SDK’s documentation.
Since 24 October 2026 it also refuses any extraArgs, any settings key the wiring checklist does
not list, and an agent definition that declares an MCP server of its own or, since 25 October
2026, names one the options do not hold. Since 25 October 2026 it refuses the few environment
variables the README lists, too. Each option is read, refused, or accepted. The reason for
accepting one is the payment tool handler’s guarantee: whatever an accepted option sets, the
handler pays only on an approval the gate recorded for that call and that payment, and at most
once in each process.
What stays outside the check:
- where the agent runs, and what its own tools can reach. A payment credential the agent can reach by any route other than the gated payment tool is outside SignetGate’s protection. Keeping it out of the agent’s reach is the integrator’s, under schedule paragraph 8.1(j);
- the host’s managed-settings tier, which Claude Code still reads from disk, as the Agent SDK documents: a plugin enabled there, or a payment tool denied there;
- the
.claudeconfiguration trees on disk, which the Agent SDK documents as coming from the working directory or from the directoryprojectConfigRootnames: agents, skills, commands, workflows and routines. The pilot runbook asks for a working directory holding no.claudetree the partner did not put there.
It can tell that the payment server came from the function the integrator gave it, not that the function is the Agent SDK’s own.
What it doesn’t affect. Compromised agents, which this detection never covered: such an agent leaves its report out and looks clean. The detection covers the honest but misconfigured integration, which is the common case.
What limits the damage today. With the PreToolUse hook installed, allowedTools and
bypassPermissions do not actually bypass the gate: hooks run first, and a hook’s denial
holds. The SDK sends its findings with every payment, and they raise AGENT_CONFIG_SHADOWED.
So the reviewer deciding the payment sees that this agent reports a configuration that might
let a call skip the control they are the last line of. Every place the finding is shown labels it
self-reported.
Since 23 October 2026 the payment tool’s own handler pays only on an approval the gate recorded for that call and that payment (entry 34). So an allow rule in a settings file cannot make the payment tool pay a call the gate has not approved: the tool refuses it, and the reviewer of the agent’s next payment sees the finding that refusal raises. A session whose settings keep the payment tool from it has every gated call refused at its first payment.
Since 18 October 2026 the SDK’s permission-callback integration is not a supported setup for a
pilot, which integrates through the SDK’s setup and its PreToolUse hook. The callback runs
after the allow rules, so a settings-file allow rule can approve a call without the callback
being asked, and the SDK cannot see that rule.
What would close it. Server-side silence detection: “API key active, zero verifications in N hours”. The server already knows every agent’s volume. It is the only check that covers both blind spots, and we treat it as the completion of shadow detection.
7. PreToolUse hook precedence is documented, not measured
Last changed: 23 October 2026.
If an integration registers another hook beside ours, upstream documents that our denial still
wins, but we have not measured that on a real install. Until it is measured, avoid registering
other PreToolUse hooks that can see a gated tool.
What it is. If an integration registers another PreToolUse hook that can see a gated
tool, the question is whether that hook’s allow can override SignetGate’s deny. The rule
that reduces several hook results into one decision lives in the Claude Code binary, not in
the SDK, and our own source cannot answer it.
Upstream now documents the answer. The
hooks page says “When multiple hooks or permission rules apply, deny takes priority over
defer, which takes priority over ask, which takes priority over allow. If any hook
returns deny, the operation is blocked regardless of other hooks”, and separately that
“all matching hooks run in parallel … Because completion order is non-deterministic, write
each hook to act independently rather than relying on another hook having run first”
(https://code.claude.com/docs/en/agent-sdk/hooks, read 22 September 2026).
That documents this entry’s risk as closed, and rules out “the first hook wins” altogether.
A documentation page is not a measurement of the binary a customer is running, and the
behaviour it describes belongs to a component we do not build and cannot inspect. So the entry
stays open, and the finding stays at warning severity, which is the answer that is wrong in
the safe direction.
What it doesn’t affect. An integration with no other hook that can see a gated tool. For that integration the question does not arise.
What limits the damage today. Registering another hook that can see a gated tool is
reported as a finding at warning severity, and it reaches the reviewer through
AGENT_CONFIG_SHADOWED. Our hook is installed first. Under the documented rule that is a hedge
that holds until the probe confirms the documented behaviour, not a mitigation the design
relies on: no documented case exists where being first decides the outcome. It costs nothing,
so it stays first.
Since 23 October 2026 the payment tool’s own handler pays only on an approval the gate recorded for that call and that payment (entry 34). So if another hook’s allow ever outweighed SignetGate’s refusal, the payment tool would still refuse the call, and the reviewer of the agent’s next payment would see the finding that refusal raises.
What would close it. A probe written for exactly this answers it empirically, and its self-test passes on 24 fixtures with no key. It has not yet been run against a real Claude Code install, so it has produced no verdict. A verdict recorded against a named Claude Code version closes this.
8. Confirmation of Payee is simulated
Last changed: 4 September 2026.
The Confirmation of Payee result in this version is simulated, and no bank is asked. Do not rely on it as a check that the payee’s name matches their account.
What it is. No Confirmation of Payee request is sent to any network. The server compares the agent’s vendor name with the invoice’s, and returns a match status.
What it doesn’t affect. How the result is presented: it is never shown as real. The
simulated flag is fixed in the code, not derived, so no configuration can make a simulated
result look live. Every place that shows a CoP result carries a persistent SIMULATED chip.
Configuring a live check is unimplemented and stops the server at boot, rather than quietly
falling back.
What limits the damage today. The labelling, and that CoP is one input to risk scoring rather than a gate on its own.
What would close it. Integration with a live CoP provider, which is out of scope for this version.
9. A single reviewer can approve any payment
Last changed: 16 October 2026.
One reviewer account can approve any payment on its own, whatever its value, and nothing in this version asks for a second approver. Until dual control exists here, keep a second approval in your own payment system for the payments that need one.
What it is. One authenticated reviewer, one decision. There is no dual control, no value threshold above which a second approver is required, and no separation between who may review and who may approve.
What it doesn’t affect. Measuring whether reviewers check. Synthetic payments, each with a planted defect, measure whether reviewers catch them, and the catch rate is reported per reviewer.
That measurement rests on a synthetic payment not being recognisable before it is decided. A test checks that a synthetic payment and a real one are alike in everything the review screen receives, so one queue response does not set a synthetic payment apart, with narrow exceptions: two kinds of correlation can show within one queue response, and neither is certain. Over several responses, two things can set one apart, and some kinds of payment are never used as synthetic payments, so are not measured. The pilot security pack, for the pilot owner, describes each.
So a reviewer who learns them could recognise some synthetic payments. The measurement is sound for its purpose, telling a reviewer who checks from one who does not, and it does not stop a reviewer who sets out to game it over many items. A system refusal of a synthetic payment is not counted as the reviewer’s catch.
From 14 October 2026 the console tells a reviewer, as soon as they decide a synthetic payment, that it was one and what was planted. A synthetic payment can carry a real supplier’s name and bank details. With reviewers refusing an item before contacting its supplier, as the pilot terms ask, nobody needs to contact a supplier about a payment that never happened. It has a cost to the measurement: over time, reviewers learn what synthetic payments look like. They would refuse those payments anyway, and refusing is the safe action, but the catch rate becomes less a measure of unprompted attention as they learn. Nothing reaches the console about a synthetic payment before it is decided.
What limits the damage today. The friction engine (a minimum time on each item, and the typed challenge), the synthetic-payment programme, and the fact that every decision is bound into signed evidence naming the reviewer account. All of that makes a bad approval attributable; none of it makes one impossible.
What would close it. Dual control, with both reviewer accounts in the receipt. This register
also names when it becomes urgent: if the rate of CHALLENGE_UNVERIFIABLE refusals stops being
rare, the control has become a reason to route invoices around SignetGate. Dual control is the
fix because the server can verify it with no invoice data at all.
Earlier findings, now fixed.
- 29 September 2026: a way to pick out synthetic payments within one queue response. Fixed.
- 29 September 2026: a scoring error that credited reviewers with catches they had not made. Fixed.
- 6 October 2026: a further way to separate synthetic from real payments within one queue response, in a narrow case. Our pre-launch testing on 5 October 2026 found it. Fixed.
10. Coverage is not uniform: some paths are tested only against stubs
Last changed: 13 November 2026.
Some parts of the product have been tested against the real running server, and others only against simplified stand-ins, and a passing test suite does not show which. If your integration relies on a particular path, ask us how it has been exercised.
What it is. “Tested” means different things in different places, and the difference is not visible from a passing suite. Some paths have been driven over real HTTP against the real server process. Others exist only in tests that call the server in the same process, or that run against the SDK’s stand-in server. A stand-in once drifted from the real server and hid an unreachable branch in a third component.
What it doesn’t affect. The API’s routes. As of 13 November 2026, all twenty-three routes have been exercised end to end against the real server process. The twenty in the first version of our endpoint-by-endpoint review table were all covered by 4 September 2026. The withdrawal route, added on 23 September 2026, is covered by a full-stack test that aborts a payment through the SDK against the real server, with the review open in the real console in a real browser, and checks that the review is withdrawn and no receipt exists. That test last passed on 16 October 2026. The outcome route, added on 14 October 2026 to tell a reviewer after a decision whether the item was a synthetic payment, is covered by a full-stack test in which the real server plants a synthetic payment and a reviewer refuses it in the real console. It checks that the route answered a synthetic and a real payment alike before the decision, refused the agent’s credential, and told them apart after. That test first passed on 15 October 2026. The readiness route, added on 28 October 2026 to tell the operator’s monitor whether a payment could be decided and signed now, is covered by a test that asks the real server process over real HTTP. It checks that the route answers ready when every check passes, and not ready, naming the disk alone, when the server’s floor for free disk space cannot be met. That test first passed on 13 November 2026.
What limits the damage today. Every route listed above has been exercised end to end against the real server. What remains is that nothing enforces the distinction, so the next route added can be tested only against a stand-in and look identical.
What would close it. A coverage rule that treats “exercised over real HTTP” as a property to be asserted rather than a habit, the same shape as the automated checks that already enforce our other repository-wide rules.
Earlier findings, now fixed.
- 4 September 2026: the first run of the real server and the real built console together found seven defects that every other test runner had passed. They included a console that never became interactive, so no button or hotkey worked at all, and an event-stream client that ended every stream at fifteen seconds. Fixed.
11. The offline checker moves the auditor’s trust, it does not remove it
Last changed: 16 October 2026.
The offline checker lets your auditor confirm a receipt without our servers, but it still depends on the public key it is given, on the checker file, and on the browser. Record our published public key yourself when you deploy, keep your own copy, and compare the checker’s SHA-256 with a copy you obtain separately.
What it is. The promise is that a customer’s auditor can confirm a receipt without us. The offline checker bundle makes that practical for someone with no developer tooling. But “without us” is a claim about dependencies, and three remain. In descending order of how much they should worry a reviewer:
- The public key. The tool answers “was this signed by the holder of the key you supplied”.
If the key came from us and we are the disputed party, that is close to circular. A firm
that may one day contest a payment should record the published key when it deploys, from
/.well-known/signetgate-keys, and keep its own copy. The checker is only as independent as the key handed to it. - The page itself. It is a file we produced. Its SHA-256 is published beside it, and the page pins its own script by hash, so a copy whose script was altered refuses to run rather than running altered. Any other change to the file shows up only against the published hash. Neither helps against someone who can change the file and the published hash together, so compare the hash against a copy obtained separately rather than from the same email.
- The browser’s Ed25519. It is deliberately not ours: no crypto library is bundled, so there is no opaque code to trust. The page tests itself against RFC 8032’s published vector before it judges anything, including confirming that it refuses a signature it should refuse, so a broken implementation is caught rather than believed. Where the engines disagree, the page does not leave the answer to them (below).
What it doesn’t affect. A browser that cannot do the check never gives a wrong verdict.
Where the browser has no Ed25519, the page reports CANNOT_CHECK and never a verdict, which
was measured, not assumed. A Safari without Ed25519 says that the browser cannot perform the
check and that nothing is wrong with the files, and points to verify.js. It can give an
unhelpful answer, never a wrong one.
What limits the damage today. verify.js is a second, independent path that uses Node’s
own crypto. The canonicaliser both share is inlined from the product’s compiled source rather
than reimplemented, so the tool cannot disagree with the system about what bytes were signed.
The page settles the known engine disagreements itself, before asking the browser anything. It refuses small-order public keys, which Chromium and Firefox accept for any message where Node refuses. It judges the certificate link by one pattern rather than by each engine’s URL parser. It reads a file as bytes rather than through the browser’s text decoder. And it refuses a key or a signature point outside the prime-order subgroup, and the identity as a signature’s R. Node, Node’s WebCrypto, Chromium and Firefox then agreed on all 172 vectors run. Safari was not among them.
Safari has been checked by hand on a Mac. The current build was checked in Safari 18.6 on
macOS 15.7.3 on 7 October 2026: all 30 cases in the check kit, the procedure for a verdict left
over from an earlier file, the two-file drop and the glyph check matched the expected results.
An earlier build was checked on 17 September 2026, when its self-test banner read green; the
Safari version was not recorded. No automated run covers Safari. The suite drives Chromium and
Firefox, which verify correctly, and Playwright’s WebKit, which throws NotSupportedError on an
Ed25519 key. That WebKit does not stand in for Safari in either direction: Apple’s Ed25519 comes
through a framework absent from the open-source WebKit build. Published support says Safari 17
and later has Ed25519.
What would close it. Making the Safari check repeatable: a Safari run over the same corpus of genuine, tampered and wrong-key receipts that the other engines are driven through, on a machine available to the suite.
Earlier findings, now fixed.
- 29 September 2026: Chromium and Firefox accepted a signature under a small-order public key for any message, where Node refused it, so the verdict depended on the browser. Measured on 28 September 2026. Fixed.
- 2 October 2026: three more engine disagreements, after our pre-launch testing on 1 October 2026. One receipt with an edited certificate link was valid in Chromium and malformed in Firefox. A UTF-16 file was valid in Chromium only. And one published edge case got different answers from Chromium, Firefox and Node. Fixed.
- 5 October 2026: a signature using the identity as R got VALID from the page in Chromium and
Firefox and SIGNATURE INVALID from
verify.jsand the command line, for a receipt signed that way by its own key’s holder. Our pre-launch testing on 4 October 2026 found it. Fixed.
12. Payee names that differ only in accented letters collide in the fingerprint
Last changed: 16 October 2026.
Two payees whose names differ only in their accented letters, such as Café Rouge and
Caf Rouge, look like the same payee to the “seen before” check when they also share a sort
code and account number. A payment to the second can then come in without the new-payee flag,
and at the STANDARD tier if nothing else fires. The account it pays is one a payment has already
been approved to.
What it is. The payee-name normaliser lowercases a vendor name and replaces every run of
characters other than unaccented letters and digits with a single space. Three things use it:
the payee fingerprint, the simulated CoP comparison, and the vendor-name row of the comparison
table. Because it keeps only unaccented letters and digits, it strips accented letters along
with punctuation. So Café Rouge becomes caf rouge, which is exactly what Caf Rouge
becomes. Two different payees, one fingerprint.
What it doesn’t affect. Hashing, signing and the evidence. payloadHash covers the vendor
name exactly as supplied, accents included, so two differently spelled names produce two
different receipts. An auditor comparing a payment instruction against a receipt gets the right
answer either way. This is about the derived value that answers “have we seen this payee
before”.
What limits the damage today. The collision needs two payees whose names differ only in
characters the normaliser discards, and the same sort code and account number, because those
are part of the fingerprint too. Where that happens, the second counts as seen before and loses
the new-payee trigger. The CoP comparison does not replace it: it compares the payment’s name
with that payment’s own invoice data, never with the earlier payee. If the invoice data names
the payee as the payment does, the simulated result is EXACT_MATCH, the vendor-name row
matches, and the payment can come in at the STANDARD tier. If the invoice data carries the
other spelling, the result is CLOSE_MATCH, which elevates. Either way the money goes to an
account a payment has already been approved to, under a name that differs only in its accented
letters.
What would close it. A Unicode-aware fold (NFKD, strip combining marks, casefold) in place of the rule that keeps only unaccented letters and digits. It was left alone deliberately. The fingerprint is stored on every verification ever created, and changing how it is computed makes every stored value incomparable with every new one. Nothing would fail. The “seen before” check would simply begin answering a slightly different question, and the records written before the change would quietly stop meaning what the records after it mean. So the fold is a migration with a backfill, and a re-check of the synthetic-payment programme, rather than a quick edit.
13. Two duty-of-care checks rest on what the server cannot verify, and the release check lives in our client
Last changed: 4 October 2026.
Every check on a receipt’s duty-of-care record is enforced for approvals, but two rest on things
the server cannot see: whether anyone read the Confirmation of Payee banner, and who typed the
password. The check that stops a payment being released on a failing record runs in our SDK,
not in the protocol. If your integration calls our API directly, make it refuse to release a
payment unless the receipt is APPROVED and its record passes.
What it is. A receipt carries six duty-of-care checks and an overall verdict, and every check is enforced for approvals: the server refuses an approval unless its record would pass, the signer refuses to sign one that does not, and the SDK refuses to release on one. What that enforcement rests on is not uniform, and two of the six rest on something the server cannot verify:
| Check | What the server observes | What it cannot verify |
|---|---|---|
copResultAcknowledged |
Only that the reviewer’s browser sent the claim | That anyone read the banner. A modified client makes the claim without reading anything, and looks exactly like an honest one |
verifierAuthenticated |
When the session began, on its own clock | Who proved the password (entry 1). Signing in again proves the same shared secret, typed more recently |
documentIntegrityVerified |
That it captured and hashed a file | What the file really says (entries 3 and 4) |
minimumDwellMet |
Time from claim to decision, on its own clock | Attention. And a clock stepped forward between the claim and the decision counts as dwell (entry 30) |
elevatedChallengePassed |
That the typed digits match the invoice data | That the invoice data is right (entry 4), and that the browser reported every rendering problem (entry 5) |
decisionWithinDeadline |
Its own clock | Anything off that clock. It is true on every receipt by construction, because a late decision is refused and no receipt exists, but “late” is measured by the server’s clock. A clock stepped back lets a decision in after the agent’s deadline (entry 14) |
Separately, refusing to release on a failed record is a property of our client, not of the protocol. The SDK reads the record and refuses. An integration that calls the API directly, or runs a modified SDK, can release a payment on any receipt it likes. The server’s refusal to sign such an approval does not depend on the client, so a server running this version does not issue one. But nothing downstream of the receipt forces anyone to read it.
What it doesn’t affect. Whether a receipt matches what the system did. Every check gates an
approval, and from this version the server does not sign an APPROVED receipt with a failed
check. Whoever holds the signing key can still sign anything outside the server (entry 18).
What limits the damage today.
- An ELEVATED approval long after sign-in is refused with
422 REAUTHENTICATION_REQUIREDrather than recorded. The reviewer signs in again, and the claim on the item is kept. - The server requires the acknowledgement claim, as the console does. The console and the certificate both present it as the browser’s report rather than a measurement.
- The signer refuses to sign an approval whose record fails. A gate missing from the decision path, for instance for a check added later, surfaces as a refusal rather than as signed evidence.
- The server, the signer and the SDK use the same conjunction of checks, from one shared implementation, declared per check: a new check fails compilation until someone says how it passes.
What would close it.
- For the acknowledgement: nothing on the server can observe reading. A per-decision WebAuthn assertion would bind the claim to a specific hardware key at the moment of decision, which is entry 1’s closure. It would still not show that the banner was read.
- For sign-in age: entry 1’s closure.
- For the release check: move it to the payment rail. A payment system that refuses an
instruction without a valid
APPROVEDreceipt whose record passes makes the check a property of the payment, not of our library.
Earlier findings, now fixed.
- 16 September 2026: the record and the release were decided separately. An ELEVATED approval
long after sign-in went through and was recorded as failing
verifierAuthenticated. The server accepted approvals without the acknowledgement claim, which only the console required, and recordedcopResultAcknowledgedas failed. And the SDK released on the decision alone, without reading the record. So a signed receipt could say a check failed on a payment that was made. Neither unenforced check was chosen; both drifted. Fixed. Receipts issued before then can carryAPPROVEDwith a failed check, so read them as such. The offline checker does not display the checks at all: it verifies the signature and shows ten identifying fields, so it calls such a receiptVALID, which it is.
14. A review can outlive the call it was opened for
Last changed: 28 October 2026.
If an agent’s call gives up while its review is still open, the review can still be approved,
leaving a signed approval for a payment that was never made. Before treating an approval as a
payment, check that the payment went out: the SDK reports an approval it could not use as
ALREADY_DECIDED, with the decision and the receipt id, for you to reconcile: on the thrown error,
and on its verification.withdrawn event, which is how a hook integration hears of it.
What it is. A gated call waits in the agent’s process while a person decides. If the waiting ends first (Claude Code cancels the hook at its timeout, the user interrupts, or the process dies), the call does not run, but the review was opened on the server and lives there until its deadline. The SDK withdraws it on every failing exit, and a withdrawn item can never be approved or signed. The failing exits are an abort, a failed poll or receipt read, a receipt that fails a check in the SDK, an unexpected error, and the SDK’s own deadline passing while the server still reports the review open. The last one happens when the server’s clock has stepped back.
What withdrawal cannot reach:
- A process that is killed outright (a crash, a forced kill, a host shut down) withdraws nothing. The review stays live until its deadline, and a reviewer can still approve it.
- An ingest that fails after it reached the server (an abort, or a request timeout while the server is still working on it) leaves nothing to withdraw by id, and the review is live. So does an answer the SDK cannot read, and an error the server sends after it stored the review: the SDK holds no verification id to withdraw by.
- A withdrawal that does not reach the server is reported to the integrator as
FAILED, on the thrown error and its event, and the review stays live. - A withdrawal the server refuses with 429. Withdrawal is limited to 60 a minute per agent, and
every failing exit withdraws, so in a burst of failing calls larger than that the excess
withdrawals are refused. Each is reported
FAILED, and its review stays live. Our pre-launch testing on 1 October 2026 measured this. - A decision that lands before the call gives up stands: the receipt exists, and the call does
not run. That covers a cancellation, and also an approval whose receipt could not be read or
failed a check. The thrown error and its
verification.withdrawnevent name it,ALREADY_DECIDED, with the decision and the receipt id, so the integrator can reconcile it, through the hook as well (since 16 October 2026). The hook’s deny reason does not, because it is returned to the model. - A hook wrapped by the integrator that drops the abort signal never learns the call was abandoned, and withdraws nothing.
In each case the approval is a genuine, signed record of a decision about a call that never ran.
If the agent then tries the payment again, that is a new tool call, and it gets its own review,
flagged PAYLOAD_PREVIOUSLY_APPROVED with the earlier approval’s reviewer account and time.
Nothing is released on the old approval. Only a re-delivery of the same tool call, with the same
call id, re-attaches to its decision.
Since 23 October 2026 the payment tool’s own handler can also leave an approval unused (entry 34). The hook denies a call whose approval the gate would not record for the payment tool, and the payment tool refuses one that reaches it past the approval’s use-by, or with a payment other than the one approved. A payment call that fails inside the integrator’s own code leaves an approval that may or may not have paid. Each is reported to the integrator, and the pilot runbook says how to reconcile it.
The one list. This entry is the one complete list of the ways a signed approval can exist with no payment known to follow it. The README, the pilot runbook, the pilot service schedule and the acceptance matrix’s record point here, and do not count the cases themselves.
Reported to the integrator through the SDK’s events:
- a withdrawal that found the review already approved (
ALREADY_DECIDED, with the decision and the receipt id): a cancellation, an interrupt, a deadline the SDK reached first, or an approval whose receipt could not be read or failed a check; - an approval the hook denied because the gate would not record it for the payment tool
(
APPROVAL_NOT_RECORDED); - an approval the payment tool refused after it was spent, or past its use-by;
- a payment call that failed inside the integrator’s own code (
payment.failed), which may or may not have paid.
Reported by nothing:
- an approval made after the agent’s process stopped, killed outright or otherwise, with the review still open;
- an approval that landed before the process stopped, but whose receipt was never handed over;
- an approval of a review whose withdrawal did not reach the server or was refused 429. The
withdrawal is reported as
FAILED, which says the review may still be approved, but not whether it was; - an approval of a review abandoned by a hook wrapper that dropped the abort signal, so that nothing was withdrawn;
- an approval the hook allowed whose payment tool then never ran, for instance because the session ended first;
- an approval whose payment tool called the integrator’s
execute, which never finished, because the process stopped orexecutenever settled, so that whether it paid is not known; - an approval of a call denied because the integrator’s
onEventthrew while the SDK raised an event. An error thrown fromonEventcan turn an approval into a denial: the call does not run, the receipt is not handed over, and no event reports it. The pilot runbook asks for anonEventthat catches its own errors (since 25 October 2026); - a second approval for one tool call, delivered again under a different idempotency key. The re-delivery gets a review of its own; once that is approved, the payment tool pays under the first approval, and the second has no payment after it. The pilot runbook asks for the key to be left to the SDK, or kept the same for every delivery of one call (since 25 October 2026);
- an approval of a review the server stored whose verification id never reached the integrator, because the answer to its ingest was lost (the process stopped, the request timed out or the connection dropped after it was sent), could not be read, or was an error.
The pilot runbook describes one reconciliation for all of them. The integrator records the
verification id from every SDK event that carries one, verification.created and
verification.withdrawn among them, reads each back from the API until it is decided, withdrawn
or expired, fetches the receipt a decided one names, and checks its payment system for each
approval under the receipt id. That finds every approval whose verification id reached the
integrator’s process, whether or not its receipt was handed over, and whether or not the process
later stopped. It cannot find the last case above: no verification id was recorded. The pilot
runbook requires the SDK to come from the same release as the deployment, so that the SDK reads
the answers its server writes, which removes the systematic cause of an answer it cannot read.
A retry can wait. After a retry or a restart, a call that re-attaches to a review that has already ended is told the decision only when its review window is over: a payment that was already decided can take up to one review window to continue. It costs time, never a payment.
What it doesn’t affect. Whether a payment is reviewed. In every case above the call did not run. The record goes the other way: an approval that no payment followed. That matters in a dispute about whether a payment was approved, where such a record overstates what happened.
What limits the damage today. The withdrawal route excludes a decision at three separate layers, each tested alone. The SDK withdraws on every failing exit and reports the outcome, and it retries a failed poll up to three times rather than giving up on the first. A reviewer holding a withdrawn item is told at their next heartbeat or decision, and cannot act on it. The hook is given longer than its gate’s review window, the requests either side of it and the withdrawal, so Claude Code does not cancel a hook whose review can still be decided.
When an agent’s last working key is revoked, by the command or by removal at start-up, its undecided reviews are withdrawn. A re-delivery of the same call that arrives while the first ingest is still fetching its document re-attaches to it.
An ingest checks its API key when it arrives, then fetches the invoice, which can take seconds, and checks the key again in the same write as the review. A key revoked in that time is refused with 401 and nothing is written, as a test shows with a document host held open across the revocation. A revocation committed after that write withdraws the review. Between the check and the write there is no wait, only the time to run them. A revocation committed in that instant makes SQLite refuse the write, so the request fails and nothing is written. That last case is SQLite’s documented rule for a read that becomes a write. Our pre-launch testing on 5 October 2026 measured it by injection, revoking the key in that instant: the request failed with HTTP 500, and nothing was written.
What would close it. Tying release to execution: a payment system that must present the receipt to release a payment, and a record of whether each approval was used, so an approval no payment followed is visible as unused rather than indistinguishable from one that paid. Short of that, withdrawal by idempotency key would reach an abort mid-ingest, and an answer the SDK could not read. In a shadow pilot an approval moves no money, so an approval with no payment after it costs evidence, not money. Whether to build each is decided before the first test-account or live-with-ceiling pilot.
Earlier findings, now fixed.
- 24 September 2026: a retry in the same session re-attached to the approved review and was released on the old approval, without a new review. Measured on 23 September over polling and SSE, and on 24 September for a second, separate call. Reviews were keyed by payment and session; they are now keyed by payment and tool call. Fixed.
- 29 September 2026: only an abort withdrew. Our pre-launch testing on 28 September 2026 found every other failing exit leaving the review approvable. One failed poll was enough, and the SDK had no retry for polls. With the server’s clock stepped back 60 seconds, the agent was told the payment was not sent, and a reviewer approved it afterwards and got a genuine receipt. Fixed.
- 3 October 2026: when an agent’s last working key was revoked, its undecided reviews stayed open, though the agent could no longer poll or withdraw. Our pre-launch testing on 1 October 2026 measured a reviewer approving one, with a signed receipt the agent could not fetch. Fixed.
- 3 October 2026: a re-delivery of the same call that arrived while the first ingest was still fetching its document was denied, and lost its review. Fixed.
- 5 October 2026: a revocation while an ingest was fetching its invoice found no review to withdraw, and the review was written after it, approvable for an agent with no working key. Our pre-launch testing on 4 October 2026 found it. Fixed.
15. The Claude Code version floor rests on what the host reports
Last changed: 24 October 2026.
Claude Code before version 2.1.208 could let a gated payment through if a query was interrupted while it waited for review. The SDK refuses those versions when it can see the version, so use our documented integration, which shows it the session’s version, and do not point it at an older Claude Code binary.
What it is. Before Claude Code 2.1.208, interrupting a query while a PreToolUse callback
was pending could let the tool call proceed. For a gate that holds its callback open while a
person decides, that is a gated payment going through with no decision at all. Two checks stand
against it. The SDK requires exactly version 0.3.304 of Anthropic’s Agent SDK, whose package
declares Claude Code 2.1.304, later than 2.1.208. And a session that reports any version other
than 2.1.304, older or newer, to the SDK’s version check has every gated call denied before
anything is sent.
Neither check can see:
- a host that points the Agent SDK at an older Claude Code binary without the SDK’s setup, which
refuses
pathToClaudeCodeExecutableat start since 23 October 2026, andexecutable,executableArgsandspawnClaudeCodeProcesssince 24 October; - an install that ignores the SDK’s declared requirement, since package managers warn about an unmet peer dependency rather than refusing, unless they are configured strictly;
- an integration that never uses the SDK’s setup, like every other check in the SDK.
A session whose version was never observed is not refused.
What it doesn’t affect. Current Claude Code versions, as far as this interrupt goes: from 2.1.208 an interrupt cancels the pending call. That is documented upstream, not measured here, with the same caveat as entry 7. This entry is about interrupts only. Entry 34 recorded other ways the gate could be bypassed in some configurations, which are now fixed.
What limits the damage today. The declared requirement; the version check failing closed on an old or unreadable version; and our integration documentation showing the version check in the only integration it documents. Since 23 October 2026 the payment tool’s own handler pays only on an approval the gate recorded for that call (entry 34), so a call that went ahead with no decision would be refused at the payment tool.
What would close it. A version the gate can read for itself when the call is made, if the hook input carried it. Or refusing gated calls in any session whose version was never observed. The second is a choice rather than a measurement: it fails closed, and it breaks every integration that does not pass its messages to the version check.
16. The same payment awaiting review twice is not flagged, and another agent’s decisions are not consulted
Last changed: 23 October 2026.
Two reviews of the same payment that are open at the same time are not linked, so both can be approved and the payment made twice, and another agent’s earlier decisions are not consulted. Keep one SDK client per agent process and one agent key per payer, and check approvals for duplicates before paying.
What it is. The server’s check for a repeated payment, PAYLOAD_PREVIOUSLY_APPROVED and
PAYLOAD_PREVIOUSLY_REJECTED, runs once, when the payment arrives. It looks for the same
payment already decided, either identical or the same once its vendor name and invoice number
are normalised. A refusal is also matched by its account. Since 5 October 2026 a payment to a
sort code and account number the same agent had refused is flagged, whatever its name, invoice
or amount. Our pre-launch testing on 4 October 2026 led to that.
Only a refusal that judges the payee counts by its account. From 6 October 2026 two kinds do not, because they say nothing about where the money would have gone, as our pre-launch testing on 5 October 2026 showed:
- the system’s own refusals,
CHALLENGE_FAILEDandCHALLENGE_UNVERIFIABLE; - a reviewer’s refusal because the invoice document was missing or unreadable, or because the payment had already been made;
- from 14 October 2026, a reviewer’s refusal because the payment is held to confirm with the supplier. A reviewer who would contact a supplier about a payment refuses it first, under this category, so the supplier’s account is not flagged for the window.
Those still match the same payment by the look-alike key, and every other refusal counts by its account. Which kind a refusal is depends only on the category the reviewer chooses, and nothing checks it: a refusal filed under any of those three categories leaves the account unflagged, and the signed receipt records the category.
The check reads the payments, not the invoice data, so it works the same whether the invoice data mirrors the payment or comes independently; what else the reviewer sees differs (entry 2). Two gaps follow.
Payments awaiting review together are not flagged. Two payments for the same invoice whose
reviews are open at the same time are flagged by nothing on the server, and neither reviewer is
shown the other. That holds for identical payments, and for the same invoice spelled
differently, such as INV-2026-100 against INV 2026 100. Measured on 24 September 2026 over
real HTTP: two identical payments arriving together became two reviews with no reason between
them. The first was approved. The second, shown after that approval, still carried no flag, and
its approval was accepted.
It looks only at the submitting agent’s own history. A decision made on a payment submitted under one agent’s API key is not consulted for another agent’s. The same payment, or a look-alike of it, submitted through a different agent key is not flagged, however recently the first was refused. That includes the account match: a payment to an account that one agent had refused is not flagged when a different agent pays it. Matching an account across agents would need the account number stored so that one lookup could find every agent’s refusals to it, and that is a database change.
So this entry covers:
- two SDK clients under one API key paying the same invoice;
- an integration that creates a new SDK client for each call;
- the same invoice spelled two ways at once;
- the same payment under two agent keys;
- a payment by one agent to an account another agent had refused.
What it doesn’t affect. Whether each payment is reviewed: each is approved by a reviewer account, after the minimum review time and, for ELEVATED items, the typed challenge. A retry after a call that failed before its payment tool ran does not produce a double payment either: the first call is no longer waiting, so approving both reviews pays once and leaves an approval that no payment followed (entry 14). A retry after a payment call whose outcome is unknown can pay twice, if the first call did pay. The retry is a new review, with a new receipt id, and so a new idempotency key for the payment API. The reviewer is asked to check the payment system before approving it, and the integrator’s own record of each invoice (below) refuses one already paid or in progress. Otherwise, two payments need two live calls for the same invoice at once, or two agent keys.
What limits the damage today.
- Within one process the SDK stops identical payments. Each SDK client holds the payments it
has awaiting review, and refuses a second call for a held payment before any review is opened
(
DUPLICATE_IN_FLIGHT), for instance the same tool called twice in one turn. It recognises a payment by its fingerprint, so it does not stop the same invoice spelled differently. Those hash differently, and reach review side by side even from one process. - A repeat made after the first review is decided, by the same agent, identical or spelled differently, is flagged, forced to ELEVATED, and shown with the earlier decision’s reviewer account and time. After a refusal that judges the payee, so is any payment by that agent to the refused account, under any vendor name, including one with letters from another script.
- Both reviews appear in the queue with the same vendor, amount and payee, and an invoice number that reads alike.
- A duplicate can be found afterwards by comparing those details across receipts’ payments, or
by matching
payloadHashwhere the two were identical. - An integration should keep one SDK client per agent process, not one per call, and one agent key per payer.
- The integrator’s own record, which the README’s wiring checklist requires: one record per invoice, holding the receipt id, written atomically before the payment API is called, and a payment tool that refuses an invoice the record shows as paid or in progress. Of two approvals for one invoice, as the integrator’s system identifies it, only one can then pay. SignetGate cannot yet look up an earlier payment’s outcome itself, so until it can, a retry after an unknown outcome relies on that record and on the reviewer.
What would close it. Flagging a matching review that is still open, when a payment arrives; checking again when a review is shown, without raising the tier of an item whose invoice account number has already been sent; and refusing an approval when a matching payment has been approved since the reviewer claimed this one. Each is a protocol addition, a reason and a refusal the console must know, and they wait until after the shadow pilots start. No schema change is needed, and the design exists. Whether a decision under one agent key should count for another is a separate question, because agent keys may belong to different customers of one deployment. For a refused account there is a design too: the account number stored for one lookup, which is a database change.
17. Whoever runs the server can weaken every control, and nothing records it
Last changed: 28 October 2026.
The thresholds, the reviewer list and the synthetic-payment rate are set by whoever operates the server, and nothing outside that operator sees them change. If someone else hosts the service for you, agree in writing who may change its configuration, and review it yourself.
What it is. SignetGate’s thresholds, its list of reviewers and its synthetic-payment rate are set by whoever operates the server, and nothing outside that operator sees them change. Every one can be loosened:
- the amount above which a payment is ELEVATED, which can be set so high that none is;
- how long a sign-in stays fresh enough to approve an ELEVATED payment;
- the confidence below which OCR’d invoice data raises the tier, which can be set to zero;
- the window in which a repeated payment is flagged;
- which document hosts are fetched;
- the synthetic-payment rate, which defaults to zero;
- the reviewer accounts themselves, which come from the server’s configuration.
The database behind all of this is a file the operator can edit. The server writes no request log. The start-up output names the mode it resolved, how sign-in is limited, and the accounts and keys it disabled or found revoked. It prints no threshold and no rate. A receipt carries no record of the configuration it was decided under.
So an operator who adds an account, raises the threshold and approves a payment produces a receipt that looks like any other. Under a pilot hosted by the supplier, the operator is the supplier. The operator also sets every reviewer’s password, so it can sign in as any existing reviewer, and a receipt it then produces names that reviewer.
What it doesn’t affect. The signing key and what it has signed: without the key, an operator cannot forge a receipt, and a change to any signed value of one is detected. Entry 18 covers who holds the key. Reviewers and the agent cannot change the configuration. And the operator’s own organisation can see it, because the configuration is theirs to review.
What limits the damage today. The dwell floors, the typed challenge and the checks on every approval are fixed in the code, not configurable. The dwell floors are measured on the server’s clock, though, and that is the operator’s: stepping it forward between a claim and a decision satisfies them (entry 30). A receipt names the reviewer account and signs its duty-of-care record, so a later reading of what was relaxed can be tested against the receipts issued under it. Removing a reviewer from the configuration ends their access at the next start (entry 1).
What would close it. Printing the effective thresholds, and a digest of them, at start, and signing that digest into every receipt, so a receipt says which configuration decided it. Beyond that, a configuration change log the operator cannot rewrite, and separation between who configures the server and who reviews on it.
18. There is no key rotation or compromise procedure
Last changed: 11 November 2026.
The server signs every receipt with one key, and there is no procedure for replacing it or for recovering from its theft. Keep your own copy of the public key, and agree with the supplier how you will be told if the key is ever suspected compromised.
What it is. The server signs with one key, and /.well-known/signetgate-keys publishes only
that key. Changing the key is possible: restart with a new one. But after a change the old key
is no longer published, so only someone who kept their own copy of it can check receipts signed
before the change. Measured on 28 September 2026: after a restart with a new key, an old
receipt was still served and checked VALID against the old key, and the
published key could no longer check it.
Nothing marks receipts signed after a compromise, and no independent timestamp exists.
decidedAt is the signer’s own statement, so a stolen key can sign a receipt dated before the
theft.
What it doesn’t affect. The strength of the signature. A receipt checked against the right key is exactly as trustworthy as that key. Key rotation is out of scope for this version, in our product documentation and in the pilot terms.
What limits the damage today. The key’s id is inside every signed receipt, so a receipt names the key it was signed with, and a checker given another key reports a key mismatch rather than a forgery. The offline checker checks against the key the auditor supplies, and the SDK against the keys pinned in it; an SDK with no pinned keys fetches the server’s (entry 19). A key pinned in the SDK does not change when the server’s does.
After a suspected compromise, the response today is manual:
- Stop the API.
- Record the time of the suspected compromise, and tell every integrator and auditor that receipts signed with that key are not evidence on their own, whatever date they carry.
- Start again with a new key.
- Hand integrators the new key to pin in place of the old one.
Nothing is re-signed.
What would close it. Publishing retired keys alongside the current one, marked retired and dated. An independent timestamp on each receipt. And a written rotation and compromise procedure that customers can hold the supplier to.
19. An SDK without pinned keys trusts the server that signs its receipts
Last changed: 28 October 2026.
If the SDK is not given the signing key, it fetches the key from the same server that signs the receipts, so a substitute server can approve its own payments. Pin the published signing key in every production integration, as the pilot terms require.
What it is. The SDK checks every receipt’s signature before it releases a payment. The key it
checks against is one the integrator pins. With no pinned keys, it fetches the key from the same
server that signed the receipt, from /.well-known/signetgate-keys.
Against a server that is compromised or impersonated, that proves nothing. The server signs with a key of its own and publishes it, and the payment is released. Measured on 28 September 2026 against a substitute server: with no pinned keys, a receipt signed with the server’s own substitute key released the payment. With pinned keys, it was refused and nothing was fetched.
The SDK refuses a key whose id, derived from the key itself, is not the id it is held under: a pinned one when the SDK is constructed, a fetched one when its receipt is checked. But a substitute server publishing its own key under that key’s true id passes every check the SDK can make.
The fallback says nothing when it is used: no event reports it, and the SDK does not know whether it is running in development or production.
What it doesn’t affect. An integration with pinned keys, which is the recommended configuration. Our product documentation, the SDK’s own documentation and the pilot terms all tell integrations to pin keys. With keys pinned, a key the SDK was not given is refused, never fetched.
What limits the damage today. Pinning. The pilot terms oblige the integration to pin the signing key.
What would close it. Refusing to start without pinned keys, or requiring an explicit opt-in to the fetch and reporting each use of it to the integration, so an integration cannot fall into it by omission. Each is a change to the SDK’s public behaviour, and comes before the first test-account or live-with-ceiling pilot.
Earlier findings, now fixed.
- 30 September 2026: the SDK accepted a fetched key whose id did not match the key it was published with. Measured on 28 September 2026 against a substitute server. Fixed.
20. A payee approved once counts as seen, for every agent and for good
Last changed: 16 November 2026.
A payment to a new payee gets extra scrutiny until a payment to that payee has been approved. After one approval, the payee counts as seen for every agent, with no time limit. Treat the flag as one signal among several, not as a check that an account is the right one.
What it is. A payment to a payee not seen before is ELEVATED: a longer wait and a typed challenge. “Seen” means an earlier approved verification with the same payee details (the vendor name, sort code and account number together), from any agent, at any time. A refused, withdrawn, expired or pending verification does not count, and nor does a synthetic payment (from 14 October 2026).
So a single approval clears the flag for good. If a reviewer approves a payment to a payee wrongly, later payments to that payee (the same name, sort code and account number) are not raised for being new, by that agent or any other.
A refusal is remembered separately. The repeated-payment check remembers a refusal that judged the payee by its account, so the same agent’s next payment to that account is ELEVATED as previously refused, whatever its invoice number or vendor name, for the look-back window (from 5 October 2026). A system refusal, or a reviewer’s because the document was missing or unreadable or the payment had already been made (from 6 October 2026), or because the payment is held to confirm with the supplier (from 14 October 2026), is remembered only for the same payment. Which kind a refusal is depends only on the category the reviewer chooses, and nothing checks it. The signed receipt records the category. Another agent’s payment to the account is not raised either way (entry 16).
What it doesn’t affect. Whether the payment is reviewed: it still goes to a person, and every other trigger still applies. A payee whose details do not match the invoice, whose simulated Confirmation of Payee result is not an exact match, or whose amount is over the threshold is still ELEVATED. The pilot terms define the trigger as the code does: no earlier approved verification.
What limits the damage today. The other triggers, and that an approval is itself a reviewer’s decision, made with the longer wait and the typed challenge that a new payee brings.
What would close it. Counting approvals within a window, or per agent. Both would add friction for suppliers that are paid regularly, and neither is decided. A related possible fix, not a plan: treating a payee with no approval for a long period, such as 12 months, as new again, because a payment to a supplier that has gone quiet is a recognised fraud signal.
Earlier findings, now fixed.
- 14 October 2026: a payee counted as seen after any earlier attempt, including one that was refused, withdrawn or left to expire, so an agent’s own attempt could clear the new-payee flag. A missed synthetic payment also made its altered account count as seen. Our pre-launch testing on 28 September 2026 found the first. Fixed.
21. Fixed: production started with the repository’s published example secrets
Last changed: 29 October 2026.
Production now refuses to start with a secret the repository’s example environment file publishes, or with a session secret shorter than 32 bytes. Set your own session secret, reviewer passwords and API keys before any deployment.
What it was. The server refused to start in production without a session secret, API keys and reviewer accounts, but not with the values printed in the repository’s example environment file, and it accepted a session secret one character long. A deployment configured by copying that file and changing only the mode would have accepted:
- a session secret anyone who has read the repository could use to make session tokens;
- reviewer passwords printed in the same file;
- an API key printed in the same file.
What SignetGate now does. In production, the server refuses to start when the session secret is the example file’s or is shorter than 32 bytes, when an API key secret is one the example file publishes, or when a reviewer password is one it publishes. Its message names the variable, and never the value. Development and test still accept them, which is what the example file is for.
What it does not check. How a secret was made. A secret of 32 bytes or more that is easy to guess, or a value published somewhere other than the example file, is not refused.
Earlier findings, now fixed.
- 29 October 2026: production started with the values the example environment file publishes, and with a one-character session secret. Our pre-launch testing on 28 September 2026 found it. Fixed.
22. The SDK leaks a listener on every call made with a reused abort signal
Last changed: 30 September 2026.
An integration that passes one long-lived abort signal to many SDK calls slowly holds more and more memory. Give each call its own abort signal, as the Claude Code hook does.
What it is. When a call to the SDK is given an abort signal, the SDK attaches a listener to it for each request it makes, and never removes one. An integration that passes one long-lived signal to many calls keeps every listener, and the memory behind it, until the signal goes away. Measured on 28 September 2026: 6,667 calls with one reused signal left 16,002 listeners and about 100 MB held.
What it doesn’t affect. Any decision. A signal per call, which is what the Claude Code hook passes, holds nothing after the call ends.
What limits the damage today. The hook’s own signal is per call. The leak grows only with a signal an integration reuses across calls.
What would close it. Removing each listener when its request settles.
23. The SDK accepts a plain-HTTP address and a review window it did not ask for
Last changed: 30 September 2026.
The SDK will talk to the server over unencrypted HTTP, or with certificate checks switched off, and will wait as long as the server tells it to. Point it only at an HTTPS address, never turn off TLS checks in the process, and pin the signing key.
What it is. Three things the SDK allows that it could refuse:
- An
http://address. The API key and the payment details then cross the network unencrypted. The SDK has no notion of development and production, so it cannot refuse this in one and allow it in the other. - TLS switched off for the whole process (
NODE_TLS_REJECT_UNAUTHORIZED=0). The SDK inherits the process’s TLS settings, and that setting disables certificate checks for every connection. - A review window longer than the server should grant. The SDK adopts the window the server returns, and does not clamp it to the server’s own limit of 10 minutes. Measured on 28 September 2026: a server answering with a 10-hour window held the call for as long as the caller let it.
What it doesn’t affect. Whether a payment needs a genuine receipt. With keys pinned (entry 19), a party in the middle of an unencrypted or unchecked connection still cannot sign an approval. It can read the traffic and the API key, delay the answer, or refuse the call.
What limits the damage today. Pinned keys. The hook’s time limit, which ends a call that waits too long and withdraws its review (entry 14). The pilot terms, which serve the API only over HTTPS, behind a TLS-terminating proxy.
What would close it. Refusing http:// except for a loopback address. Clamping an adopted
window to the server’s published limit. Telling the integration when TLS verification is off.
24. A slow document host can hold every capture slot, and payments are refused
Last changed: 16 November 2026.
A document host that answers very slowly can tie up the server’s invoice fetches until every payment is refused. Allowlist only document hosts you control or trust to answer promptly.
What it is. The server fetches each invoice itself, a small fixed number at once, with the rest queued. A fetch has a deadline for connecting and a limit on how long a connection may stay silent, but no limit on its total time. So a document host on the allowlist that answers very slowly holds a slot for as long as it keeps sending.
Enough such fetches hold every slot. Later submissions queue behind them, the SDK’s submissions time out, and every payment is refused. When the queued captures finish, they create reviews that no agent is waiting for (entry 14).
What it doesn’t affect. Whether a payment can get through: it fails closed. And it needs a host on the allowlist, which the operator sets.
What limits the damage today. The allowlist. The concurrency cap stops a slow host from exhausting the server’s connections as well.
What would close it. A total deadline for each fetch and each capture, not only an idle timeout and a deadline for connecting.
Earlier findings, now fixed.
- 6 October 2026: connecting had no deadline of its own. An address that never answered held a slot for the operating system’s connect timeout, by default about 21 seconds on Windows and 127 on Linux (documented defaults, not measured), and the host’s next address was never tried. Our pre-launch testing on 5 October 2026 found it. Fixed.
25. Failed sign-ins can fill the server’s disk
Last changed: 16 November 2026.
Anyone who can reach the sign-in page can make the server store a small record for each attempt, kept for a day. From one client address that is bounded at about 9 MB; from many, it adds up, and when the disk is full every payment is refused. Put the console behind a proxy that limits request rate, and watch the database’s size.
What it is. Each failed sign-in is recorded, so that the lockout survives a restart: under a keyed hash of the id it named, which is a fixed size, for any id, real or not. A record is deleted by a successful sign-in to that id, or at the first sign-in attempt more than a day after its last failure. The sign-in route allows 30 attempts a minute per client address (entry 29), which bounds what one address can hold at about 9 MB (measured on 16 October 2026). Many addresses can hold that much each.
Space freed by deleted records is reused, not returned to the disk. When the database cannot be written, every payment is refused.
What it doesn’t affect. Access, and any decision already made. It fails closed.
What limits the damage today. The fixed size of a record, its 24-hour life, and the limit of 30 attempts a minute per address, which together bound what one address can hold. Beyond that, the disk’s size, and whatever limits the network in front of the console places on requests.
What would close it. A limit on sign-in attempts that does not depend on the client’s address, or a sign-in that is not open to anyone who can reach the page (single sign-on, entry 1’s closure).
Earlier findings, now fixed.
- 3 October 2026: the sign-in route had no rate limit at all. Fixed in part: it now allows 30 attempts a minute per client address, which is not enough on its own (above).
- 16 October 2026: the id was stored as typed, of any length, and a record for an id no reviewer holds was never deleted. Three requests added 5.8 MB (measured 28 September 2026), and a password typed into the id field stayed in the database in clear. Fixed: a keyed hash, a 256-character limit, and deletion 24 hours after the last failure.
26. After one lockout, a single wrong password locks a reviewer out again
Last changed: 16 November 2026.
Someone who knows a reviewer’s id can keep that reviewer locked out of the console, because one wrong password after a lockout locks the account again. Have more than one reviewer able to approve, and ask reviewers to report a lockout they did not cause: the server keeps no lasting record of failed sign-ins.
What it is. Five wrong passwords lock a reviewer account for 15 minutes. The count of failures is reset by a successful sign-in, or 24 hours after the last failure, and not when the lockout ends. So after the first lockout, one more wrong password locks it again.
Reviewer ids are not secret: they are printed on every receipt and certificate. So an outsider who can reach the sign-in page can keep a reviewer from signing in. After four hours without a sign-in, that reviewer cannot approve an ELEVATED payment either (entry 13).
What it doesn’t affect. Access: a lockout refuses everyone, including the attacker. It fails closed, and payments wait or expire.
What limits the damage today. Other reviewers are unaffected. While a reviewer has failed sign-ins on record, the database holds their count, the times of the first and last, and when any lockout ends, under a keyed hash of the reviewer’s id. That reviewer’s next successful sign-in deletes the record, and so does the first sign-in attempt more than 24 hours after the last failure. The server logs no failed sign-in anywhere else, so once that record is deleted nothing shows the lockouts happened. Measured on 9 October 2026; the 24-hour deletion since 16 October 2026.
What would close it. Resetting the count when a lockout ends, or counting failures in a sliding window, so that one wrong password after a lockout does not lock the account again. The per-address sign-in limit, in place since 3 October 2026, does not close it: keeping a reviewer locked out takes far fewer attempts than it allows. Replacing password sign-in with single sign-on, entry 1’s closure, would move sign-in and its lockout policy to the firm’s identity provider.
27. Responses carrying payment details are not marked uncacheable
Last changed: 30 September 2026.
Browsers and caches between the reviewer and the server are not told not to keep copies of pages that show payment details. Serve the console only over HTTPS, and have your proxy send headers that forbid caching and require HTTPS.
What it is. No response from the API sets Cache-Control, directly or through the console’s
proxy. The queue, the review, receipts and certificates carry payment details, so a browser or
an intermediate cache is free to keep a copy. The event streams are the exception: they are
marked no-cache. The console’s pages also announce the framework they run on
(X-Powered-By).
The pilot terms do not say that the TLS terminator in front of the service must send
Strict-Transport-Security.
What it doesn’t affect. Access to another reviewer’s data: every route that carries payment details requires a session or the owning API key, and a cache shared between users would still need that session.
What limits the damage today. Sessions. HTTPS between the browser and the service, which the pilot terms require in production.
What would close it. Cache-Control: no-store on every API response. Dropping the
X-Powered-By header. Naming HSTS in the pilot terms as the TLS terminator’s job.
28. Fixed: invoice data was shown without isolating its text direction
Last changed: 29 October 2026.
The console now draws a sort code or account number from invoice data with its digits in the order stored, whatever characters it carries, and shows a direction-control character in it as its code point, marked, rather than applying it.
What it was. The integration supplies the invoice’s sort code and account number as free-form
text, which the server stores as given. The console showed them in the “On invoice” column
without isolating their text direction, so a value carrying Unicode direction-control characters
could display with its digits in a different order from the one stored. The comparison’s result
was right throughout: it runs on the stored text, so a value that differs from the agent’s reads
MISMATCH however it displays.
What SignetGate now does. Every value the console shows from the agent’s side, in the queue, the comparison, the simulated Confirmation of Payee result and the codes of the agent’s own configuration report, is isolated from the text around it, and any format or control character in it is shown as its code point, marked. A sort code, an account number and an amount are also drawn left to right in a bidirectional override, so no character in them, a right-to-left letter included, can reorder their digits. Each value is also clipped to its own box, so that no value can paint over the rest of the page. A value longer than 140 characters, or one that does not fit its box, is cut, with the cut marked and a control that shows the whole value, scrolling inside the same box.
What it does not change. The server still accepts these characters in the invoice’s sort code and account number, and stores them as given. Accepting only printable characters there is planned, and is not in this build.
Earlier findings, now fixed.
- 29 October 2026: a direction-control character, or a right-to-left letter, in the invoice’s sort code or account number could make its digits display in a different order from the one stored. Our pre-launch testing on 28 September 2026 found the first, and our review of this fix on 29 October 2026 the second. Fixed.
29. Only submitting, withdrawing, signing in and the readiness check are rate-limited
Last changed: 16 November 2026.
One API key or one signed-in session can make as many status, stream and receipt requests as the server will accept, and what that does to the server under load has not been measured. Put a reverse proxy with rate limits in front of the API, and keep the console behind its own proxy.
What it is. Each API key may submit 60 verifications a minute, and withdraw 60. Each client
address may try to sign in 30 times a minute, and ask the readiness route an operator’s monitor
polls 30 times a minute. Reviewers’ sign-ins reach the API through the
console’s server, so the API counts each reviewer’s own address only when the operator gives it
the console’s addresses, and then reads the console’s X-Forwarded-For from that address and no
other. Unset, every reviewer counts as the console, and a flood of attempts sent through the
console keeps them all from signing in, though not from working in sessions they hold, so
production refuses to start without it. Set, it rests on the proxy in front of the console
writing the client’s address: a console reachable without that proxy lets a client choose the
address it is counted as. The per-account lockout holds either way.
Nothing else is limited:
- polling a verification’s status;
- the per-verification event stream, and how many of them one key holds open;
- the reviewers’ queue stream, and how many of them one session holds open;
- reading receipts and certificates.
So one API key, or one signed-in session, can make as many of those requests, and hold as many streams open, as the server will accept. What that does to the server under load was to be measured in the fixes that followed our pre-launch testing on 28 September 2026, with up to 2,000 streams from one key, polling at volume, and one item buried among many. That measurement was not run. The harness was stopped before it ran, so the effect is not known.
Each open stream also re-checks its session or API key before every event it writes and at every keepalive (entry 1). That is a few indexed database reads per open stream per event, so its cost grows with the number of streams held open. That cost has not been measured either, with many streams open or with few.
Several costs inside a request are known. The look-alike lookup when a payment arrives (entry 16), and choosing each synthetic payment (entry 9), read the agent’s own history synchronously, so their cost grows with the number of payments the agent has: with tens of thousands on one agent, each can take from a fraction of a second to more than a second (measured on 5 and 6 October 2026). Bounding them takes database changes, which wait until after the shadow pilots start.
Sign-in’s password hash runs off the event loop, but on the same small pool of worker threads that document capture’s address lookups use, so a payment’s arrival waits behind sign-ins in flight. Our pre-launch testing on 4 October 2026 found this, and measured the delay growing with each sign-in in flight. A capture cannot time out this way, but enough sign-ins at once would make an arrival outlast the SDK’s request limit, which is entry 14’s “ingest that fails after it reached the server”; that is extrapolated, not measured.
The SDK’s side of a limit is narrower than it looks. It honours a Retry-After on a poll, and
one longer than the time left ends the wait at once and withdraws the review (measured on
1 October 2026). So a single 429 from a proxy in front of the API costs the review. It fails
closed: the call is refused.
What it doesn’t affect. Approving, altering or reading another agent’s payments: every one of those requests needs the owning API key or a reviewer session. And overload fails closed. A server that cannot answer releases nothing, and the SDK refuses the call.
What limits the damage today. Authentication on every route. Whatever limits the reverse proxy in front of the API enforces, which the pilot terms do not specify.
What would close it. Per-key limits on polling and on open streams, a per-session limit on queue streams, the look-alike key in an indexed column, a stored flag for whether a refusal judges the payee, written with the decision, sampling synthetic payments from a bounded range, an index on decision time, a thread pool or a limit of its own for the sign-in hash, a sign-in limit per IPv6 prefix, and a load measurement that says where the server stops answering.
Earlier findings, now fixed.
- 3 October 2026: sign-in’s password hash ran on the event loop, so sign-in attempts held other requests. Fixed: it runs off the event loop, at the cost above.
- 5 October 2026: the look-alike lookup grew with every other agent’s rows too. The database chose the wrong index and read the whole table on every ingest, as our pre-launch testing on 4 October 2026 found. Fixed: it reads only the submitting agent’s rows (the first table).
- 6 October 2026: choosing a synthetic payment read the whole table through the wrong index, as the lookup had. Our pre-launch testing on 5 October 2026 found it. Fixed in part: it reads only the agent’s rows (the second table).
- 29 October 2026: one API key could make a payment’s arrival do disproportionate work. An oversized submission, malformed in a particular way, took the server far longer to refuse than an ordinary one, and held other requests while it did. Fixed: the server measures such a submission before it validates it, and refuses it at once.
- 29 October 2026: an agent whose configuration report held more findings than the server allowed had every payment refused, though the SDK reports one for each co-registered hook or agent in automatic mode, which the start-up check accepts. Fixed: the limit leaves room for any configuration a person writes, and each kind is stored once.
30. The server’s clock decides dwell and the deadline, and a step in it counts
Last changed: 16 November 2026.
The minimum review time and the decision deadline are measured on the server’s clock, so whoever runs the server can satisfy or stretch them by stepping it. Compare the two dwell figures each receipt carries: a large gap between them is the sign of a step.
What it is. serverDwellMs, from which minimumDwellMet is computed, is the difference
between two readings of the server’s wall clock: when the item was claimed and when it was
decided. A step in that clock between the two counts as dwell. Our pre-launch testing on
1 October 2026 measured this: with the clock stepped forward, an approval the server would
otherwise have refused as too quick was accepted, and its receipt recorded the minimum dwell as
met.
The deadline rests on the same clock. A clock stepped back lets a decision in after the agent has given up (entries 13 and 14).
What it doesn’t affect. What reviewers, clients and the agent can do: no request moves the server’s clock. Forging or altering a receipt. And small corrections: a clock that only slews, as time synchronisation usually does, changes dwell by milliseconds, not seconds.
What limits the damage today. Only whoever runs the server can step its clock (entry 17). Every receipt signs both the dwell the server measured and the dwell the reviewer’s browser reported, so a step shows as a gap between them: the browser reporting under a second beside a server figure of ten.
What would close it. Measuring dwell on a monotonic clock, which a step in the wall clock does not move. That holds within one process. A claim made before a restart has no monotonic reading to measure from, so a decision on it would need to be refused, or its dwell recorded as unmeasured.
31. The address classifier treats three IPv6 forms as public
Last changed: 4 October 2026.
Three rare kinds of IPv6 address are treated as public when the server decides whether it may fetch an invoice from them. No way to exploit them is known, and a host must be on your allowlist first, so keep the document allowlist short.
What it is. Before an invoice document is fetched, the address its host resolves to is classified, and private, loopback, link-local and special-purpose addresses are refused. IPv6 forms that carry an IPv4 address inside them are classified by that IPv4 address: IPv4-mapped, IPv4-compatible, NAT64 and 6to4. Three forms are not, and classify as public:
- Teredo,
2001::/32, which carries an obscured IPv4 address; - IPv4-translated,
::ffff:0:0:0/96; - the deprecated site-local range,
fec0::/10.
Our pre-launch testing on 1 October 2026 found this by reading.
What it doesn’t affect. Any known path to the address these forms carry: none is routed to an IPv4 host by an ordinary network stack. Hosts outside the allowlist: a document host must be on the operator’s list before any address it resolves to is classified, so an agent cannot name an arbitrary host.
What limits the damage today. The host allowlist. The block on link-local and cloud metadata addresses in every mode. The fetch being pinned to the address that was checked, so there is no second lookup to change it.
What would close it. Classifying Teredo and IPv4-translated addresses by the IPv4 address they carry, and refusing site-local outright, each with a row in the classifier’s table test.
Earlier findings, now fixed.
- 4 October 2026: our published description of the classifier said “IPv6 forms that carry an IPv4 address” without naming which, which was wider than the code. Fixed.
32. A reviewer’s refusal reason can look like a system refusal
Last changed: 5 October 2026.
A reviewer, using a modified console or the API directly, can write a refusal reason that looks like one of the system’s own codes. When reading a refused receipt, do not assume a code-like reason came from the system.
What it is. A refusal’s reason is signed into the receipt. The system’s own refusals give a
code as the reason, such as CHALLENGE_FAILED. Since 3 October 2026 a reviewer’s reason that is
one of those codes is refused, compared ignoring case and surrounding space. A closer copy is
not. CHALLENGE_FAILED with an invisible character appended, or with a Cyrillic letter in place
of a Latin one that looks the same, is accepted and signed as written, as our pre-launch testing
on 4 October 2026 measured. A reader of the receipt sees what looks like the system’s refusal.
What it doesn’t affect. Any measure. Metrics and synthetic-payment scoring compare the reason exactly, so they count such a refusal as the reviewer’s own, which it is. Nor the console, which builds a reason from a chosen category and free text, so it takes a modified client or a direct request with a reviewer’s session. And the payment is refused either way.
What limits the damage today. The exact comparison above, and the console.
What would close it. Comparing after removing invisible characters and folding letters that look alike (Unicode TR39), or keeping the system’s refusals in a field of their own. The second is a schema change.
33. A receipt’s certificate link is not signed
Last changed: 16 October 2026.
A receipt file may carry a link to a certificate, and the signature does not cover it. Anyone holding the file can add the link or change it, and the receipt still checks VALID. Do not follow a link found in a receipt. Check the receipt with the offline checker against the public key you recorded, and get its certificate from the console.
What it is. The signature covers every field of a receipt except the signature itself and
certificateUrl, an optional link to the receipt’s certificate. The offline checker and
verify.js accept that field in one form only, https:// followed by a host and a path, and
refuse any other value as a malformed receipt. A receipt with a link added, or with its
link changed to another address of that form, gets the verdict it would get without one: VALID,
if its signed fields are intact.
What it doesn’t affect. The verdict, and anything shown with it. No checker reads the link: none shows it or opens it, and the contents shown under a valid signature do not include it. Nor does the SDK or the console: the console builds its certificate link from the receipt’s id. Our server does not write the field into the receipts it issues, so a receipt that carries one had it added after it was signed.
What limits the damage today. The single accepted form, which keeps out other schemes and any markup, and the checkers’ silence about the link.
What would close it. Refusing the field in every reader, since nothing writes it. That changes the receipt format the checkers accept, so it waits for the next checker release.
34. Fixed: the gate could be bypassed in some integration configurations
Last changed: 29 October 2026.
Our pre-pilot integration audit of 17 October 2026 found ways the gate could be bypassed in some configurations. The fix is in place, and the audit was repeated against it and passed. Integrate as the README’s wiring checklist says.
What it was. The audit ran the real Claude Agent SDK and Claude Code, at the oldest version SignetGate then supported and at the current release, in configurations an integrator might choose. In some of them the gate did not hold. This entry first said the details would be published when the fixes shipped. We have since decided not to publish them. It describes what SignetGate now requires and does, and how the fix was tested.
What SignetGate now requires and does.
- The payment tool’s own handler is bound to the gate, and checks the decision. It pays only on an approval the gate recorded for that call and that payment, and at most once in each process, whatever runs between the hook and it. A refusal executes nothing and is reported with its code.
- SignetGate refuses to start a configuration in which that handler cannot do its job: a payment tool not served in the agent’s own process from the gate’s payment server, a payment tool the main session cannot call, Claude Code’s minimal mode, a plugin, an environment for the agent that is missing or is not an object of variables, or a payment credential named in its environment, settings, extra arguments or MCP server configuration.
- It refuses to start unless
settingSourcesis[]andstrictMcpConfigistrue; what each option does is in the Agent SDK’s documentation. It also refuses anyextraArgs, a settings key the wiring checklist does not list, agent definitions it cannot read or that name an MCP server the options do not hold, an option that changes what runs as Claude Code, and the few environment variables the README lists. - Claude Code is pinned to the version the acceptance matrix passed, and a session on any other version has its gated calls refused.
- The hook gives no decision for a tool it does not gate.
How the fix was tested. Each behaviour has its own test, beside a mutation that shows the test can fail. The audit was then repeated against the fix, at Claude Code 2.1.304, as SignetGate’s acceptance matrix, on 21 and 22 October 2026. Nothing was paid without a review, and no approval paid twice in the cases it ran. Those did not include a call delivered again after a restart, which the README describes. One check could not be measured, because measuring it needs a setup the wiring checklist tells integrators never to use. The matrix’s rows were run again as the start-up check grew: every row on 24 October 2026, and rows 1 and 5 on 26 October 2026. Each passed.
What remains. What the start-up check cannot see stays with the integrator, through the README’s wiring checklist. Entry 6 lists it. That includes where the agent runs: a payment credential the agent can reach other than through the payment tool is outside SignetGate’s protection.
35. The comparison is only as independent as the integration builds it
Last changed: 3 November 2026.
The console compares the payment with the invoice data, and your integration builds both. Build the payment from what the agent passed to the payment tool, and the invoice data from your finance system. Built from one source, every field matches whatever the agent did, and the console cannot tell you so.
What it is. The comparison table is a check because its two columns come from different places: the payment the agent asked for, and what your finance system holds for the invoice. Entry 4 covers invoice data read from the document itself. SignetGate cannot see where either column came from: our server keeps only a fingerprint of the tool’s arguments, the console shows none of them, and the payment tool’s handler compares the payment its mapping builds with the one approved. So:
- a payment built from the same finance record as the invoice data, as a payment tool that takes only an invoice number has to build it, matches that record in every field by construction, under the column headed Agent extracted;
- invoice data copied from the tool’s arguments compares the agent with itself.
In either case the risk trigger for a mismatched field never fires. Neither can be told from a correct integration whose agent’s figures agree with your records. An integration built in our development rehearsal of 31 October 2026, from our own documentation, did the first.
What it doesn’t affect. What does not rest on the comparison: the server’s own capture of the invoice document, the risk triggers that read the payment itself, such as the new-payee trigger, which reads the history of approved payments, the reviewer’s own reading of the invoice, and the signed receipt, which binds the payment that was approved.
What limits the damage today. The README states the rule and its reason, and the pilot quick start repeats the reason. Before a pilot’s first day, a deliberate test call whose arguments differ from the finance record in one field must show that field as a mismatch in the console, and is refused. Signetry confirms from the deployment’s records that the field was compared as a mismatch and the call refused.
What would close it. Nothing on SignetGate’s side can see how an integration builds the two columns. A check in the SDK that the payment’s values appear among the tool’s arguments is possible, but a tool may carry a payment in another shape, so it could only ever warn. It is under consideration, and is not in this build.
36. A restore from backup, or a crash of the host, can lose decisions already answered
Last changed: 12 November 2026.
If the deployment is restored from a backup, or its host loses power or its operating system crashes, the server can lose decisions it has already answered, and their receipts. A restore loses everything since the last good backup, normally up to a day; a crash of the host can lose the decisions answered shortly before it: roughly the last half minute by the operating system’s default settings, which we have not measured on the server. Either way, your integration may hold signed receipts for decisions the server has no record of. Keep every receipt as each decision is made: your copy is then the record.
What it is. Backups are taken daily. A restore puts the deployment back as it stood at the backup, so it loses the reviews, decisions and receipts made since, the invoice files captured for them, sign-in records, and the history of approved payees that the new-payee flag reads. A crash of the host loses less. The server answers a decision as soon as its database has recorded it, without waiting for the disk. The operating system writes it to disk shortly afterwards, within about half a minute by its default settings. We have not measured that on the server. After a restore or a crash, the review behind a lost decision is open again or gone, and could be decided a second time under a new receipt id.
What it doesn’t affect. A receipt you hold. It was signed before it was sent, and it checks VALID against the public key you recorded whether or not the server still holds it. Nor a crash of the API process alone, with the host still running: a decision the server has answered survives it.
What limits the damage today. Your own copy of each receipt, which the pilot terms ask you to keep as each decision is made. In a shadow pilot no payment follows from a decision. After a restore or a host crash we tell you the period that may have been lost and ask for the receipts you hold from it. We accept each one that checks VALID and was decided in that period, before any receipt the server does not hold is treated as a sign of a stolen key (entry 18).
What would close it. Writing each decision to disk before answering it would close the crash case; it is not in this build. More frequent backups, or a continuous copy of the database’s log kept apart from it, would narrow what a restore loses; neither is in this build either.
37. Nothing in the SDK tells a shadow integration from a paying one
Last changed: 11 November 2026.
A shadow pilot moves no money because the payment tool pays nothing. That is how your integration is built, and nothing in SignetGate checks it. Build from the shadow-mode starter, keep payment credentials out of your integration’s process, and confirm both to us in writing before the first day.
What it is. Shadow is not a mode of the SDK. The payment tool’s handler is your code, and on an approval the SDK runs whatever it does. The deployment’s pilot mode changes only what a certificate says. The onboarding self-check reads the set-up, not what the handler does. So an integration built from the README’s example, which pays, in a deployment set to shadow, is a paying integration, and nothing SignetGate prints would show it.
What it doesn’t affect. The starter. As shipped it calls no payment API and names no payment credential.
What limits the damage today. The pilot terms, under which the payment tool records an approval and instructs no payment. The README and the pilot pack lead with the starter. Before a pilot’s first day the partner confirms in writing that its handler instructs no payment and that its integration’s process holds no payment credential, and we note it in the deployment’s record.
What would close it. Nothing in the SDK can see what a handler does. It stays a confirmation.
38. An integration that sets its own idempotency key can release two calls on one approval
Last changed: 11 November 2026.
Your mapCall may return its own idempotency key. If it returns the same key for two separate
tool calls for one payment, the second is released on the first one’s approval, with no review of
its own, and your payment tool’s handler runs for both. Leave the key out, as the pilot runbook
says, and keep one record per invoice.
What it is. Left to the SDK, the key is made from the payment and the call’s id, so each call gets a review of its own. A key the mapper supplies is used as given. Two calls that share one reach one review, and the handler then runs once for each call, with the same receipt id.
What it doesn’t affect. An integration whose mapper returns no key, as the README’s example and the starter do not. A re-delivery of one call, which runs the handler once.
What limits the damage today. One record per invoice, written before anything is paid, which the README’s wiring checklist requires and the starter implements: the second run is refused. A payment API that takes the receipt id as its idempotency key pays once. In a shadow pilot nothing pays.
What would close it. The SDK refusing to record one receipt for two calls, so that the second is denied. It changes what the hook decides, so it comes before any real-money pilot.
39. One person operates every pilot
Last changed: 11 November 2026.
Signetry’s operation and incident response are one person. Support hours are Monday to Friday, 09:00 to 17:30 UK time; outside them incidents are handled on best efforts. There is no second operator to stop the service or notify you if that person is unavailable.
What it is. One person administers the hosting account, operates each deployment and answers incidents. Alerts go to that person alone.
What it doesn’t affect. What the service does when nobody is watching. If it is down or cannot be reached, the SDK refuses every call, so nothing is approved by default.
What limits the damage today. The first pilots are shadow pilots, in which no payment waits on SignetGate. Each partner is told this in writing before a pilot starts.
What would close it. A second operator, with written cover for absence.