@kreiseck/kasseneck-api 0.9.3 → 0.10.0

package/dist/esm/payments/hobex-hps/index.js

@@ -19,8 +19,8 @@
  */
 export { createHpsConnectClient, } from './connect-client.js';
 export { HpsClarifyTimeoutError, HpsConnectException, HpsConnectTerminalError, HpsConnectTransportError, HpsPreflightError, HpsTransactionIdError, PREFLIGHT_CONNECT_CODES, } from './errors.js';
-export { mayRetrySafely, } from './outcome.js';
+export { isHostUncertainResult, mayRetrySafely, } from './outcome.js';
 export { createHpsPayments, } from './payments.js';
 export { MAX_TRANSACTION_ID_LENGTH, createHpsTransactionIdGenerator, isValidHpsTransactionId, newHpsTransactionId, } from './transaction-id.js';
-export { ABORTED_CODE, APPROVED_CODE, CARD_NOT_PRESENT_CODE, HPS_MEASURED_CODES, INVALID_TRANSACTION_CODE, NOT_ABORTABLE_CODE, INVALID_AMOUNT_CODE, AMOUNT_OUT_OF_RANGE_CODE, INVALID_TID_CODE, WRONG_PIN_CODE, NO_STATEMENT_CODE, TECHNICAL_ERROR_CODE, TERMINAL_BUSY_HTTP_STATUS, TRANSACTION_CANCELED_CODE, isApproved, isCanceled, isConclusive, isInProgress, isNoStatement, isNotAbortable, isTechnicalError, isUnknownCode, parseHpsTransactionResponse, } from './transaction-response.js';
+export { ABORTED_CODE, APP_SELECT_FAILED_CODE, APPROVED_CODE, BAD_REQUEST_CODE, CARD_DECLINED_CODE, CARD_INFO_NOT_ENTERED_CODE, CARD_NOT_PRESENT_CODE, CARD_NOT_SUPPORTED_CODE, CARD_READ_FAILED_CODE, CHIP_DATA_MISMATCH_CODE, COMPLETION_FAILED_CODE, DIAGNOSIS_FAILED_CODE, HOST_COMMUNICATION_FAILED_CODE, HOST_STEP_FAILED_CODE, HOST_TIMEOUT_REVERSED_CODE, HPS_CODES, HPS_MEASURED_CODES, HPS_REASON_HINTS, INTERNAL_ERROR_CODE, INVALID_MESSAGE_TYPE_CODE, INVALID_TID_DOCUMENTED_CODE, INVALID_TX_TYPE_CODE, MAX_RETRIES_EXCEEDED_CODE, NOT_FOUND_CODE, PASSWORD_NOT_ENTERED_CODE, REFUND_DISABLED_CODE, REFUND_PASSWORD_INVALID_CODE, SCEP_ENROLLMENT_FAILED_CODE, TERMINAL_BLOCKED_CODE, TERMINAL_BUSY_CODE, TIP_SELECTION_FAILED_CODE, UNSUPPORTED_USER_DATA_CODE, hpsCodeInfo, hpsCodeReason, isHostUncertain, isHostUncertainReason, INVALID_TRANSACTION_CODE, NOT_ABORTABLE_CODE, INVALID_AMOUNT_CODE, AMOUNT_OUT_OF_RANGE_CODE, INVALID_TID_CODE, WRONG_PIN_CODE, NO_STATEMENT_CODE, TECHNICAL_ERROR_CODE, TERMINAL_BUSY_HTTP_STATUS, TRANSACTION_CANCELED_CODE, isApproved, isCanceled, isConclusive, isConclusiveAsStatus, isInProgress, isNoStatement, isNotAbortable, isTechnicalError, isUnknownCode, parseHpsTransactionResponse, } from './transaction-response.js';
 export { hobexReceiptFromHps } from './receipt.js';

package/dist/esm/payments/hobex-hps/outcome.d.ts

@@ -1,4 +1,4 @@
-import type { HpsTransactionResponse } from './transaction-response.js';
+import { type HpsCodeReason, type HpsTransactionResponse } from './transaction-response.js';
 /**
  * Ausgang eines Kartenzahlvorgangs — die einzige Frage, die ein Aufrufer
  * wirklich hat: darf ich es nochmal versuchen?
@@ -35,6 +35,18 @@ export interface HpsPaymentResult {
      * Entscheidung getragen. Bei schluessigem Ausgang nicht gesetzt.
      */
     readonly lastResponse?: HpsTransactionResponse;
+    /**
+     * Worauf die Kasse reagiert -- der Grund hinter dem Ausgang, mit dem Satz
+     * fuer den Bediener in `HPS_REASON_HINTS`.
+     *
+     * Gesetzt an der Stelle, die den Ausgang entschieden hat, nicht aus
+     * [response] abgeleitet: ein bestaetigter Abbruch antwortet `'0'` und ist
+     * trotzdem `'aborted'`, und wenn die Zwei-9027-Regel eine Zahlung als
+     * abgelehnt klaert, zaehlt der Code der ZAHLUNG, nicht das `9027` danach.
+     * Fehlt, wenn kein Code etwas erklaert (die Leitung riss ab, bevor das
+     * Terminal etwas sagte) und bei einer Aufhebung, die nicht gegriffen hat.
+     */
+    readonly reason?: HpsCodeReason;
     /**
      * Verlauf der Klaerung, in Reihenfolge — der Nachweis, der im
      * Belastungsstreit gelesen wird. Behauptet nie eine Ursache, die nicht
@@ -44,3 +56,10 @@ export interface HpsPaymentResult {
 }
 /** Nur bei `'declined'` steht fest, dass nichts belastet wurde. */
 export declare function mayRetrySafely(result: Pick<HpsPaymentResult, 'outcome'>): boolean;
+/**
+ * `true`, wenn der Ausgang offen ist, weil das Terminal eine Stoerung beim
+ * oder nach dem hobex-Host meldete (`effect: 'hostUncertain'`). Wichtig fuer
+ * jede SPAETERE Nachfrage: antwortet die Statusabfrage dann `9027`, heisst das
+ * hier NICHT "nichts belastet".
+ */
+export declare function isHostUncertainResult(result: Pick<HpsPaymentResult, 'outcome' | 'reason'>): boolean;

package/dist/esm/payments/hobex-hps/outcome.js

@@ -1,4 +1,14 @@
+import { isHostUncertainReason } from './transaction-response.js';
 /** Nur bei `'declined'` steht fest, dass nichts belastet wurde. */
 export function mayRetrySafely(result) {
     return result.outcome === 'declined';
 }
+/**
+ * `true`, wenn der Ausgang offen ist, weil das Terminal eine Stoerung beim
+ * oder nach dem hobex-Host meldete (`effect: 'hostUncertain'`). Wichtig fuer
+ * jede SPAETERE Nachfrage: antwortet die Statusabfrage dann `9027`, heisst das
+ * hier NICHT "nichts belastet".
+ */
+export function isHostUncertainResult(result) {
+    return result.outcome === 'unresolved' && isHostUncertainReason(result.reason);
+}

package/dist/esm/payments/hobex-hps/payments.d.ts

@@ -89,6 +89,25 @@ import type { HpsPaymentResult } from './outcome.js';
  * Kein [tryAbort]-Versuch bei [cancel]: die Originalzahlung ist laengst
  * abgeschlossen und antwortet gemessen mit `100010` -- ein Abbruch darauf
  * waere sinnlos.
+ *
+ * ## Stoerung beim Host: die Klaerung darf nichts schliessen (11.09.2026)
+ *
+ * Die Antwortcodeliste von hobex benennt Codes, bei denen der Host beteiligt
+ * war und das Terminal NICHT selbst storniert (`effect: 'hostUncertain'`,
+ * etwa `100007`). Fuer sie gilt zweierlei:
+ *
+ * 1. Die Zwei-9027-Regel ([ausGeschlossenerAntwort]) greift nicht. Sie
+ *    schliesst aus "das Terminal hat geantwortet und nichts gespeichert" auf
+ *    "nichts belastet" -- das stimmt fuer einen Vorgang, der am Terminal
+ *    endete, aber nicht fuer einen, dessen Ausgang beim Host liegt. Dasselbe
+ *    gilt sinngemaess fuer [cancel]: ein unveraendertes `'0'` auf die
+ *    Originalzahlung beweist dann nicht, dass die Aufhebung beim Host nicht
+ *    ankam.
+ * 2. Die Klaerung wartet trotzdem nicht das ganze Budget ab. Sagt die
+ *    Statusabfrage zweimal in Folge nichts Neues (`9027` oder erneut ein
+ *    solcher Code), endet sie sofort als `unresolved` -- das Terminal wird es
+ *    auch in 90 Sekunden nicht wissen. Meldet sie dagegen `'0'`, ist die
+ *    Zahlung genehmigt, ganz normal.
  */
 export interface HpsPaymentsOptions {
     /** Wie lange insgesamt geklaert wird, bevor der Ausgang offen bleibt. Vorgabe 90 s. */

package/dist/esm/payments/hobex-hps/payments.js

@@ -1,6 +1,6 @@
 import { HpsClarifyTimeoutError, HpsConnectException, HpsConnectTerminalError, HpsPreflightError, } from './errors.js';
 import { newHpsTransactionId } from './transaction-id.js';
-import { isApproved, isCanceled, isConclusive, isNoStatement, isNotAbortable, isTechnicalError, isUnknownCode, NOT_ABORTABLE_CODE, TECHNICAL_ERROR_CODE, TRANSACTION_CANCELED_CODE, } from './transaction-response.js';
+import { hpsCodeInfo, hpsCodeReason, isApproved, isCanceled, isConclusive, isConclusiveAsStatus, isHostUncertain, isNoStatement, isNotAbortable, isTechnicalError, isUnknownCode, NOT_ABORTABLE_CODE, NOT_FOUND_CODE, TECHNICAL_ERROR_CODE, TRANSACTION_CANCELED_CODE, } from './transaction-response.js';
 /** Teiler, mit dem das Abbruchbudget aus [HpsPaymentsOptions.resolveBudgetMs] entsteht. */
 const ABORT_BUDGET_DIVISOR = 6;
 export function createHpsPayments(client, target, options = {}) {
@@ -56,7 +56,34 @@ export function createHpsPayments(client, target, options = {}) {
             return null;
         steps.push('Terminal beschaeftigt (HTTP 409) -- die Anfrage wurde nicht angenommen, es ist nichts geschehen');
         emit('resolved', steps[steps.length - 1], id);
-        return { outcome: 'declined', transactionId: id, steps: [...steps] };
+        return { outcome: 'declined', transactionId: id, reason: 'terminalBusy', steps: [...steps] };
+    }
+    /**
+     * Benennt einen Code mit `effect: 'hostUncertain'` fuer den Nachweis: was
+     * das Terminal meldet, mit Code und hobex-Titel. Die Folgerung setzt der
+     * Aufrufer dazu.
+     */
+    function stoerung(res) {
+        const info = hpsCodeInfo(res.responseCode);
+        const was = info.reason === 'internalError'
+            ? 'interner Fehler des Terminals'
+            : 'Stoerung zwischen Terminal und hobex-Host, das Terminal storniert nicht selbst';
+        return `Terminal meldet ${was} (${info.code} "${info.title}")`;
+    }
+    /**
+     * Der Grund eines offenen Ausgangs. [antwort] ist die Antwort auf die
+     * ERZEUGENDE Anfrage (oder die zuerst gemeldete Stoerung), [letzte] die
+     * zuletzt gelesene Statusabfrage. Eine Stoerung beim Host geht vor; sonst
+     * erklaert der Code der erzeugenden Anfrage mehr als ein `9027` danach.
+     */
+    function offenerGrund(antwort, letzte) {
+        if (antwort && isHostUncertain(antwort))
+            return hpsCodeReason(antwort.responseCode);
+        if (letzte && isHostUncertain(letzte))
+            return hpsCodeReason(letzte.responseCode);
+        if (antwort?.responseCode !== undefined)
+            return hpsCodeReason(antwort.responseCode);
+        return hpsCodeReason(letzte?.responseCode);
     }
     /** Verlaufseintrag fuer eine direkte Antwort, die den Ausgang NICHT festschreibt. */
     function offeneAntwort(res) {
@@ -66,6 +93,12 @@ export function createHpsPayments(client, target, options = {}) {
         if (isTechnicalError(res)) {
             return `Antwort mit technischem Fehler (${TECHNICAL_ERROR_CODE}) -- keine Aussage ueber den Vorgang, Ausgang wird geklaert`;
         }
+        if (isHostUncertain(res)) {
+            return `${stoerung(res)} -- ob belastet wurde, weiss das Terminal nicht, Ausgang wird geklaert`;
+        }
+        if (res.responseCode === NOT_FOUND_CODE) {
+            return `Terminal kennt den Vorgang nicht (${res.responseCode} "Not Found") -- keine Aussage, Ausgang wird geklaert`;
+        }
         if (isUnknownCode(res)) {
             return `Terminal nennt einen unbekannten Code (${res.responseCode})${klartext(res)} -- Ausgang wird geklaert`;
         }
@@ -79,6 +112,22 @@ export function createHpsPayments(client, target, options = {}) {
         if (isTechnicalError(status)) {
             return `Status: technischer Fehler (${TECHNICAL_ERROR_CODE}) -- keine Aussage ueber den Vorgang`;
         }
+        if (isHostUncertain(status)) {
+            return `Status: ${stoerung(status)} -- keine Aussage`;
+        }
+        // Bewusst NICHT "keine Auskunft": das Wort steht fuer das gemessene 9027,
+        // und Aufrufer lesen es als solches (sastre, OpenCardPaymentService).
+        if (status.responseCode === NOT_FOUND_CODE) {
+            return `Status: Vorgang nicht gefunden (${status.responseCode}) -- keine Aussage`;
+        }
+        const info = hpsCodeInfo(status.responseCode);
+        if (info?.rejectsRequest) {
+            return `Status: Abfrage abgewiesen (${info.code} "${info.title}") -- keine Aussage ueber den Vorgang`;
+        }
+        if (info?.conclusive && !isApproved(status)) {
+            // Nur erreichbar nach einer Stoerung beim Host, siehe [resolve].
+            return `Status: abgelehnt (${info.code} "${info.title}") -- nach der Stoerung beim hobex-Host entscheidet nur eine Genehmigung`;
+        }
         if (isUnknownCode(status)) {
             return `Status: unbekannter Code (${status.responseCode})${klartext(status)} -- keine Aussage`;
         }
@@ -95,14 +144,27 @@ export function createHpsPayments(client, target, options = {}) {
         const text = res.responseText?.trim();
         return text ? ` "${text}"` : '';
     }
-    /** Ordnet eine Terminal-Antwort ein. `null`, wenn sie nichts entscheidet. */
-    function fromResponse(res, id, steps) {
+    /**
+     * Ordnet eine Terminal-Antwort ein. `null`, wenn sie nichts entscheidet.
+     *
+     * [aufhebung]: die Antwort gehoert zu [cancel]. Ein `'0'` heisst dort
+     * "aufgehoben", und der Grund ist `'canceled'` statt `'approved'`.
+     */
+    function fromResponse(res, id, steps, aufhebung = false) {
         if (!isConclusive(res))
             return null;
         const approved = res.responseCode === '0';
-        steps.push(approved ? 'Terminal: genehmigt' : `Terminal: abgelehnt (${res.responseCode})`);
+        steps.push(approved
+            ? 'Terminal: genehmigt'
+            : `Terminal: abgelehnt (${res.responseCode} "${hpsCodeInfo(res.responseCode).title}")`);
         emit('resolved', steps[steps.length - 1], id);
-        return { outcome: approved ? 'approved' : 'declined', transactionId: id, response: res, steps: [...steps] };
+        return {
+            outcome: approved ? 'approved' : 'declined',
+            transactionId: id,
+            response: res,
+            reason: approved && aufhebung ? 'canceled' : hpsCodeReason(res.responseCode),
+            steps: [...steps],
+        };
     }
     /**
      * Ordnet die DIREKTE Antwort auf einen Aufhebungs-Request ein. Fast dasselbe
@@ -128,7 +190,7 @@ export function createHpsPayments(client, target, options = {}) {
             steps.push(`Aufhebung mit ${TRANSACTION_CANCELED_CODE} beantwortet -- mehrdeutig, der Zustand der Originalzahlung wird abgefragt`);
             return null;
         }
-        return fromResponse(res, id, steps);
+        return fromResponse(res, id, steps, true);
     }
     /**
      * Ordnet die Statusabfrage einer OFFENEN AUFHEBUNG ein. `null`, wenn sie
@@ -183,7 +245,7 @@ export function createHpsPayments(client, target, options = {}) {
         if (voided) {
             steps.push(`Terminal: Aufhebung bestaetigt (${status.responseCode ?? status.state})`);
             emit('resolved', steps[steps.length - 1], id);
-            return { outcome: 'approved', transactionId: id, response: status, steps: [...steps] };
+            return { outcome: 'approved', transactionId: id, response: status, reason: 'canceled', steps: [...steps] };
         }
         if (isApproved(status)) {
             if (firstQuery) {
@@ -199,14 +261,15 @@ export function createHpsPayments(client, target, options = {}) {
     /**
      * [letzteAntwort] ist die letzte Antwort, die das Terminal in dieser
      * Klaerung gab -- als `lastResponse` fuer Anzeige und Katalog,
-     * ausdruecklich NICHT als `response`.
+     * ausdruecklich NICHT als `response`. [grund] siehe [offenerGrund].
      */
-    function open(id, steps, letzteAntwort) {
+    function open(id, steps, letzteAntwort, grund) {
         emit('resolved', steps[steps.length - 1], id);
         return {
             outcome: 'unresolved',
             transactionId: id,
             ...(letzteAntwort ? { lastResponse: letzteAntwort } : {}),
+            ...(grund ? { reason: grund } : {}),
             steps: [...steps],
         };
     }
@@ -271,26 +334,46 @@ export function createHpsPayments(client, target, options = {}) {
         }
         steps.push('Abbruch bestaetigt -- der Vorgang war noch abbrechbar, es ist nichts belastet');
         emit('resolved', steps[steps.length - 1], id);
-        return { outcome: 'declined', transactionId: id, response: res, steps: [...steps] };
+        return { outcome: 'declined', transactionId: id, response: res, reason: 'aborted', steps: [...steps] };
     }
-    /** Klaert einen offenen Ausgang: erst abbrechen, dann abfragen -- bis das Terminal etwas sagt oder das Budget aufgebraucht ist. */
     /**
-     * `antwortMitCode` heisst: das Terminal hat auf die ERZEUGENDE Anfrage eine
-     * Antwort MIT Ergebniscode geliefert, deren Bedeutung wir nur nicht kennen.
-     * Dann ist der Vorgang am Geraet abgeschlossen -- und erst dadurch bekommt
-     * [NO_STATEMENT_CODE] (`9027`) beim Pollen einen Aussagewert, den es sonst
-     * nicht hat. Siehe [ausGeschlossenerAntwort].
+     * Klaert einen offenen Ausgang: erst abbrechen, dann abfragen -- bis das
+     * Terminal etwas sagt oder das Budget aufgebraucht ist.
+     *
+     * [antwort] ist die Antwort auf die ERZEUGENDE Anfrage, sofern eine kam.
+     * Traegt sie einen Ergebniscode, dessen Bedeutung wir nur nicht kennen, ist
+     * der Vorgang am Geraet abgeschlossen -- und erst dadurch bekommt
+     * `9027` beim Pollen einen Aussagewert, den es sonst nicht hat. Siehe
+     * [ausGeschlossenerAntwort]. Meldet sie eine Stoerung beim Host
+     * ([isHostUncertain]), bekommt `9027` diesen Aussagewert gerade NICHT --
+     * siehe Klassendoku, "Stoerung beim Host".
      */
-    async function resolve(id, steps, antwortMitCode = false, letzteAntwort) {
+    async function resolve(id, steps, antwort) {
         emit('resolving', 'Ausgang offen, Klaerung laeuft', id);
         const start = now();
         const elapsedMs = () => now() - start;
-        const aborted = await tryAbort(id, steps, elapsedMs);
-        if (aborted)
-            return aborted;
+        const antwortMitCode = antwort?.responseCode !== undefined;
+        // Einmal gemeldet, bleibt die Stoerung stehen -- auch wenn erst die
+        // Statusabfrage sie nennt und danach 9027 kommt.
+        let stoerungsAntwort = antwort && isHostUncertain(antwort) ? antwort : undefined;
+        let letzteAntwort = antwort;
+        if (stoerungsAntwort === undefined) {
+            const aborted = await tryAbort(id, steps, elapsedMs);
+            if (aborted)
+                return aborted;
+        }
+        else {
+            // Der Vorgang ist am Terminal schon beendet -- mit einer Stoerung beim
+            // Host. Ein quittierter Abbruch bewiese nur, dass am Terminal nichts mehr
+            // laeuft, nicht, dass der Host nichts belastet hat.
+            steps.push('Kein Abbruchversuch -- das Terminal hat den Vorgang mit einer Stoerung beim hobex-Host beendet');
+        }
         let wait = 0;
         let transportFailures = 0;
         let ohneAuskunft = 0;
+        // Beantwortete Statusabfragen in Folge, die zu einem Vorgang mit
+        // Host-Stoerung nichts Neues sagen.
+        let stoerungOhneNeues = 0;
         while (elapsedMs() < resolveBudgetMs) {
             if (wait > 0) {
                 const left = resolveBudgetMs - elapsedMs();
@@ -315,23 +398,45 @@ export function createHpsPayments(client, target, options = {}) {
                 wait = nextWait(wait);
                 continue;
             }
-            const settled = fromResponse(status, id, steps);
-            if (settled)
-                return settled;
+            if (isHostUncertain(status))
+                stoerungsAntwort ??= status;
+            const hostUngewiss = stoerungsAntwort !== undefined;
+            // Auf die Statusabfrage entscheidet nur ein Code, der den gesuchten
+            // Vorgang beschreibt -- nicht einer, der diese Abfrage abweist
+            // ([isConclusiveAsStatus]). Nach einer Stoerung beim Host entscheidet nur
+            // noch eine Genehmigung: jede andere Aussage des Terminals betrifft seinen
+            // Speicher, nicht den des Hosts.
+            if (hostUngewiss ? isApproved(status) : isConclusiveAsStatus(status)) {
+                const settled = fromResponse(status, id, steps);
+                if (settled)
+                    return settled;
+            }
             if (isNoStatement(status)) {
                 ohneAuskunft += 1;
-                const geklaert = ausGeschlossenerAntwort(id, steps, status, antwortMitCode, ohneAuskunft);
-                if (geklaert)
-                    return geklaert;
+                if (!hostUngewiss) {
+                    const geklaert = ausGeschlossenerAntwort(id, steps, status, antwortMitCode ? antwort : undefined, ohneAuskunft);
+                    if (geklaert)
+                        return geklaert;
+                }
             }
             else {
                 ohneAuskunft = 0;
             }
+            // Nach einer Stoerung ist jede Antwort ausser '0' (die oben schon
+            // entschieden hat) "nichts Neues".
+            stoerungOhneNeues = hostUngewiss ? stoerungOhneNeues + 1 : 0;
             steps.push(statusOhneErgebnis(status) ?? 'Status: noch kein Ergebniscode');
+            if (stoerungOhneNeues >= 2) {
+                // Siehe Klassendoku, "Stoerung beim Host": das Terminal weiss es
+                // nicht, und es wird es auch nicht wissen, wenn wir weiterfragen.
+                steps.push('Statusabfrage zweimal ohne Neues nach einer Stoerung beim hobex-Host -- '
+                    + 'das Terminal kann nicht sagen, ob belastet wurde, Ausgang bleibt offen');
+                return open(id, steps, letzteAntwort, offenerGrund(stoerungsAntwort ?? antwort, letzteAntwort));
+            }
             wait = nextWait(wait);
         }
         steps.push('Ausgang bleibt offen');
-        return open(id, steps, letzteAntwort);
+        return open(id, steps, letzteAntwort, offenerGrund(stoerungsAntwort ?? antwort, letzteAntwort));
     }
     /**
      * Liest `9027` beim Pollen als "nicht genehmigt" -- aber NUR, wenn das
@@ -356,10 +461,15 @@ export function createHpsPayments(client, target, options = {}) {
      * entstuende die Doppelbelastung vom 24.08.2026 an einer neuen Stelle.
      * Dieselbe Absicherung traegt bereits [fromCancelStatus].
      *
+     * [antwort] ist die Antwort MIT Code auf die erzeugende Anfrage -- oder
+     * `undefined`, wenn keine kam; dann greift die Regel nicht. Ihr Code ergibt
+     * den `reason`: er erklaert den Ausgang, das `9027` danach nicht. Der
+     * Aufrufer ruft diese Regel NICHT fuer eine Stoerung beim Host.
+     *
      * `undefined` heisst: nicht entschieden, weiter pollen.
      */
-    function ausGeschlossenerAntwort(id, steps, status, antwortMitCode, ohneAuskunft) {
-        if (!antwortMitCode)
+    function ausGeschlossenerAntwort(id, steps, status, antwort, ohneAuskunft) {
+        if (!antwort)
             return undefined;
         if (ohneAuskunft < 2)
             return undefined;
@@ -371,6 +481,7 @@ export function createHpsPayments(client, target, options = {}) {
             outcome: 'declined',
             transactionId: id,
             response: status,
+            reason: hpsCodeReason(antwort.responseCode),
             steps: [...steps],
         };
     }
@@ -390,11 +501,17 @@ export function createHpsPayments(client, target, options = {}) {
      *
      * Budget, Backoff und Transportfehler-Deckelung sind unveraendert aus
      * [resolve] uebernommen.
+     *
+     * [antwort] ist die direkte Antwort auf den Aufhebungs-Request, sofern eine
+     * kam. Meldete sie eine Stoerung beim Host, entscheidet ein unveraendertes
+     * `'0'` nichts -- siehe Klassendoku, "Stoerung beim Host".
      */
-    async function resolveCancel(id, steps, letzteAntwort) {
+    async function resolveCancel(id, steps, antwort) {
         emit('resolving', 'Ausgang offen, Klaerung laeuft', id);
         const start = now();
         const elapsedMs = () => now() - start;
+        const hostUngewiss = antwort !== undefined && isHostUncertain(antwort);
+        let letzteAntwort = antwort;
         let wait = 0;
         let transportFailures = 0;
         // Zaehlt nur BEANTWORTETE Statusabfragen -- Grundlage der Karenz fuer den
@@ -425,6 +542,16 @@ export function createHpsPayments(client, target, options = {}) {
                 wait = nextWait(wait);
                 continue;
             }
+            if (hostUngewiss && isApproved(status) && answeredQueries >= 2) {
+                // Siehe Klassendoku, "Stoerung beim Host": das unveraenderte '0'
+                // spiegelt nur den Speicher des Terminals. "Hat nicht gegriffen"
+                // fuehrte nach dem Tagesabschluss zu einer Rueckerstattung, die der
+                // Kunde doppelt bekaeme, falls der Host die Aufhebung doch verbucht hat.
+                steps.push('Terminal: Originalzahlung steht unveraendert (0), aber die Aufhebung endete mit einer '
+                    + 'Stoerung beim hobex-Host -- ob sie dort gewirkt hat, kann das Terminal nicht sagen, '
+                    + 'Ausgang bleibt offen');
+                return open(id, steps, letzteAntwort, offenerGrund(antwort, letzteAntwort));
+            }
             const settled = fromCancelStatus(status, id, steps, answeredQueries === 1);
             if (settled)
                 return settled;
@@ -436,7 +563,7 @@ export function createHpsPayments(client, target, options = {}) {
             wait = nextWait(wait);
         }
         steps.push('Ausgang bleibt offen');
-        return open(id, steps, letzteAntwort);
+        return open(id, steps, letzteAntwort, offenerGrund(antwort, letzteAntwort));
     }
     async function pay(paymentOptions) {
         const id = paymentOptions.transactionId ?? newHpsTransactionId();
@@ -475,7 +602,7 @@ export function createHpsPayments(client, target, options = {}) {
                 return settled;
             steps.push(offeneAntwort(res));
         }
-        return resolve(id, steps, res?.responseCode !== undefined, res);
+        return resolve(id, steps, res);
     }
     /**
      * Gutschrift mit geklaertem Ausgang -- EXAKT derselbe Klaerweg wie [pay]
@@ -519,7 +646,7 @@ export function createHpsPayments(client, target, options = {}) {
         // Dieselbe Klaerfunktion wie [pay]: die Kennung ist die des NEUEN
         // Vorgangs, eine Statusabfrage darauf liefert also genau dessen Ausgang,
         // und der Abbruch ist derselbe Diskriminator wie bei einer Zahlung.
-        return resolve(id, steps, res?.responseCode !== undefined, res);
+        return resolve(id, steps, res);
     }
     /**
      * Aufhebung (Storno/Void) einer bestehenden Zahlung mit geklaertem Ausgang.