@nelsonlongxiang/dsh-open-a2a-net 0.6.30 → 0.6.32

package/lib/faces/wire.js

@@ -3,14 +3,78 @@ import { TRANSCRIPT_DEFAULT_LIMIT, TRANSCRIPT_MAX_LIMIT } from "../session-trans
 import { refuseIfBudgetExhausted } from "../recursion-guard.js";
 import { peerPayloadFingerprint, WIRE_ERROR_IDEMPOTENCY_CONFLICT, WIRE_ERROR_REPLAY_REJECTED } from "../idempotency-store.js";
 import { briefOf } from "../task-ledger.js";
+import { parseReceipt, taskIdRefusal } from "../receipt.js";
+import { buildAuthorization, claimCovers, refusalOf } from "../task-auth.js";
+import { isRootOriginUrl } from "../origin-claim.js";
 import { WIRE_ERROR_PAYLOAD_TOO_LARGE, withinRouteBodyCap } from "../transport-caps.js";
+/**
+ * #139 (design §4.4): add `settlement: {status:'refused', reason, task_id}`
+ * to whatever JSON object this response ends with. The delivery face has
+ * many exits (mailbox, no-wait, waiting, refusals); deferring the head until
+ * the body is known keeps one rule for all of them. A non-JSON or non-object
+ * body is sent unchanged.
+ */
+export function withSettlementField(res, settlement) {
+    const writeHead = res.writeHead.bind(res);
+    const end = res.end.bind(res);
+    let head;
+    res.writeHead = (status, headers) => {
+        head = { status, headers: { ...(headers ?? {}) } };
+        return res;
+    };
+    res.end = (body) => {
+        let out = body;
+        if (typeof body === 'string') {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed))
+                    out = JSON.stringify({ ...parsed, settlement });
+            }
+            catch { /* not JSON: unchanged */ }
+        }
+        if (head !== undefined) {
+            if (out !== undefined && 'Content-Length' in head.headers)
+                head.headers['Content-Length'] = Buffer.byteLength(out);
+            writeHead(head.status, head.headers);
+        }
+        return end(out);
+    };
+}
+/** The origin of a card URL for the authorization record; the raw text, bounded, when it does not parse. */
+const originOf = (url) => {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return url.slice(0, 256);
+    }
+};
+/** Same scheme/host/port; false when either side is empty or malformed. */
+function sameOrigin(a, b) {
+    try {
+        return a !== '' && b !== '' && new URL(a).origin === new URL(b).origin;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * #187: what a verified claim may vouch for at settlement. The signing key always (the card was
+ * fetched and its key verified); the ORIGIN only when the claim URL is that origin's root — a card
+ * fetched from a path under an origin proves the path's publisher, not the origin's host.
+ */
+export function settlerClaimFields(claim, originOf) {
+    if (!claim.ok || claim.cli === true || claim.card === undefined || claim.callerUrl === undefined)
+        return {};
+    return { ...(isRootOriginUrl(claim.callerUrl) ? { claimOrigin: originOf(claim.callerUrl) } : {}), claimKey: claim.card.publicKey };
+}
 /**
  * Register the small wire faces on a settled web server.
  * @param webServer - the settled host web server.
  * @param d - the captures listed on {@link WireDeps}.
  */
 export function registerWireFaces(webServer, d) {
-    const { ctx, logger, config, cliDeposits, canvasStore, sessionNodes, joinedSessions, idempotencyStore, verifyOriginClaim, callerLinkedToThisHost, recordActivity, secretEqual, a2aCallerRefusal, scanSessionLogList, readSessionLogTail, taskLedger, refuseIfFlooded, settleAndAnnounce, session, resolveAgentForTeam, parseCanvasTeamName, canvasLiveAgent, wakeColdTeam, probeConsumption, steerRelay, fromClause, armReceiptAutosend, receiptExpectationOf, armAsyncNudge, liveAgent, callerIsAgent, selfRouteText, noWakeFaceText, archivedColdMatchText, noColdMatchText, nativeTeamsPrepare, nativeTeamsRound, routeIntoAgent, } = d;
+    const { ctx, logger, config, cliDeposits, canvasStore, sessionNodes, joinedSessions, idempotencyStore, verifyOriginClaim, callerLinkedToThisHost, recordActivity, secretEqual, a2aCallerRefusal, a2aCallerAdmission, allowlistVersionNow, observeAuthorization, scanSessionLogList, readSessionLogTail, taskLedger, refuseIfFlooded, settleAndAnnounce, session, resolveAgentForTeam, parseCanvasTeamName, canvasLiveAgent, wakeColdTeam, probeConsumption, sessionTeamOf, localSessionOfHandle, steerRelay, fromClause, sanitizeFromClause, armReceiptAutosend, eventCountOf, receiptExpectationOf, armAsyncNudge, liveAgent, callerIsAgent, selfRouteText, noWakeFaceText, archivedColdMatchText, noColdMatchText, nativeTeamsPrepare, nativeTeamsRound, routeIntoAgent, } = d;
     // gh#45 CLI 户口卡面 (peer face, unsigned card serve): the deposited
     // CLI's SIGNED card is served verbatim under its own base URL — an
     // OriginClaim verification of a CLI envelope fetches exactly here
@@ -41,7 +105,7 @@ export function registerWireFaces(webServer, d) {
         },
     }), 'a2a: cli deposit card face');
     // gh#41 fleet planning, peer-write face: a LINKED peer may regulate this
-    // host's canvas teams (create / add-member / remove-member) with a
+    // host's canvas teams (create / add-member / remove-member / remove) with a
     // VERIFIED OriginClaim envelope. The owner's ruling: any peer composes
     // and regulates the whole fleet — the bilateral/operator link IS the
     // authorization, the envelope proves the key, and every op lands in the
@@ -75,6 +139,16 @@ export function registerWireFaces(webServer, d) {
                             send(200, JSON.stringify({ ok: false, error: `untrusted-origin: OriginClaim verification failed (${claim.reason}) — canvas regulation requires a signed envelope`, code: -32000 }));
                             return;
                         }
+                        // This host edits its own canvas through the local control, never
+                        // through this peer face. A claim naming OUR origin is an envelope
+                        // we stamped on some outbound request (a card fetch to any tracked
+                        // peer, linked or not) being replayed at us: the claim is stateless
+                        // and binds no target, so the same-host basis must not admit it here.
+                        if (sameOrigin(claim.callerUrl, d.ownCardUrl)) {
+                            recordActivity('in', 'fleet-canvas', claim.caller, false);
+                            send(200, JSON.stringify({ ok: false, error: 'a host does not regulate its own canvas through the peer face (replayed self envelope refused)' }));
+                            return;
+                        }
                         if (!callerLinkedToThisHost(claim.caller, claim.callerUrl, claim.card)) {
                             recordActivity('in', 'fleet-canvas', claim.caller, false);
                             send(200, JSON.stringify({ ok: false, error: `caller "${claim.caller}" is not linked to this host — canvas regulation requires the operator link (bilateral seed, canvas ref, or same-host membership)` }));
@@ -82,23 +156,35 @@ export function registerWireFaces(webServer, d) {
                         }
                         const op = body.op;
                         const name = typeof body.name === 'string' ? body.name : '';
-                        const id = typeof body.id === 'string' ? body.id : '';
+                        const rawId = typeof body.id === 'string' ? body.id : '';
+                        // gh#131: a peer names our sessions by handle — the session it names, for removal.
+                        const id = (isRemoteMemberRef(rawId) ? localSessionOfHandle(rawId) : undefined) ?? rawId;
                         let payload;
                         if (op === 'create') {
                             const stored = canvasStore.create(name);
                             payload = stored === undefined ? { ok: false, error: 'invalid name or team cap reached' } : { ok: true, members: canvasStore.membersOf(stored) };
                         }
                         else if (op === 'add-member') {
-                            const memberValid = isRemoteMemberRef(id) ? validRemoteMemberRef(id) : id !== '' && (sessionNodes.has(id) || joinedSessions.has(id));
+                            // gh#131: a handle is stored as sent, even one of this host's own — the
+                            // local tiers read it as the session it names at route time.
+                            const memberValid = isRemoteMemberRef(rawId) ? validRemoteMemberRef(rawId) : rawId !== '' && (sessionNodes.has(rawId) || joinedSessions.has(rawId));
                             payload = name === '' || !memberValid
                                 ? { ok: false, error: 'name and a member (joined session id, or a zone-qualified remote team handle) are required' }
-                                : (canvasStore.create(name), { ok: canvasStore.addMember(name, id), members: canvasStore.membersOf(name) });
+                                : (canvasStore.create(name), { ok: canvasStore.addMember(name, rawId), members: canvasStore.membersOf(name) });
                         }
                         else if (op === 'remove-member') {
-                            payload = { ok: name !== '' && canvasStore.removeMember(name, id), members: name !== '' ? canvasStore.membersOf(name) : undefined };
+                            // Either shape may be stored (an older edit kept the handle): remove both (review of PR #151 P2-1).
+                            const removed = name !== '' && [...new Set([id, rawId])].map(each => canvasStore.removeMember(name, each)).some(Boolean);
+                            payload = { ok: removed, members: name !== '' ? canvasStore.membersOf(name) : undefined };
+                        }
+                        else if (op === 'remove') {
+                            // Dissolve. Idempotent: a team that is not here (another peer got
+                            // there first) is the outcome the caller asked for — `removed`
+                            // says which it was.
+                            payload = name === '' ? { ok: false, error: 'name is required' } : { ok: true, removed: canvasStore.remove(name) };
                         }
                         else {
-                            payload = { ok: false, error: 'op must be create | add-member | remove-member' };
+                            payload = { ok: false, error: 'op must be create | add-member | remove-member | remove' };
                         }
                         recordActivity('in', 'fleet-canvas', `${claim.caller}:${String(op)}`, payload.ok);
                         logger.info(`a2a: fleet canvas op from ${claim.caller} (${String(op)} ${name}${id !== '' ? ` ${id}` : ''}) -> ${payload.ok ? 'applied' : `refused: ${payload.error ?? '?'}`}`);
@@ -242,6 +328,8 @@ export function registerWireFaces(webServer, d) {
                 let body;
                 try {
                     body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    if (body === null || typeof body !== 'object' || Array.isArray(body))
+                        throw new TypeError('query body must be a JSON object'); // #168: `null` read body.task_id in this 'end' callback → uncaught → host exit, no auth needed
                 }
                 catch {
                     const payload = JSON.stringify({ error: 'malformed body', code: -32000 });
@@ -328,6 +416,8 @@ export function registerWireFaces(webServer, d) {
                 let body;
                 try {
                     body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    if (body === null || typeof body !== 'object' || Array.isArray(body))
+                        throw new TypeError('direct body must be a JSON object'); // #168: `null` read body.team in this async 'end' callback → unhandled rejection → host exit
                 }
                 catch {
                     const payload = JSON.stringify({ error: 'malformed body', code: -32000 });
@@ -370,6 +460,15 @@ export function registerWireFaces(webServer, d) {
                     res.end(payload);
                     return;
                 }
+                // #114 S5: a caller-born id must be header-safe — refused before
+                // admission, claim or steer, so nothing is booked under it.
+                const idRefusal = taskIdRefusal(taskId);
+                if (idRefusal !== undefined) {
+                    const payload = JSON.stringify({ error: idRefusal, code: -32000, team, task_status: 'TASK_STATE_FAILED' });
+                    res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
+                    res.end(payload);
+                    return;
+                }
                 // Phase-3 admission (owner ruling 2026-09-01, decision-seat
                 // filed): an inbound direct delivery must show a SHARED team.
                 // Local-zone callers are judged synchronously and exactly — the
@@ -383,21 +482,27 @@ export function registerWireFaces(webServer, d) {
                 // (0.6.15: the rule now lives in a2aCallerRefusal so the
                 // read-only /a2a/log face admits callers by exactly the same
                 // standard as message delivery.)
-                const callerRefusal = a2aCallerRefusal(caller, team);
-                if (callerRefusal !== undefined) {
+                const admission = a2aCallerAdmission(caller, team);
+                const callerRefusal = refusalOf(admission);
+                if (callerRefusal !== undefined || !admission.ok) {
                     recordActivity('in', team, caller === '' ? 'anonymous' : caller, false);
                     const payload = JSON.stringify({ error: callerRefusal, code: -32000, team, task_status: 'TASK_STATE_FAILED' });
                     res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
                     res.end(payload);
                     return;
                 }
+                // #114 S6: a version an inbound record is born under is always in the history.
+                observeAuthorization('lazy');
+                // #114 S2: the version is read at admission time, beside the decision it explains.
+                const admittedAt = { version: allowlistVersionNow(), at: Date.now() };
                 // gh#9+gh#10 OriginClaim on the delivery face (M1): an envelope
                 // that is present but unverifiable rejects untrusted-origin; an
                 // ABSENT envelope during the window walks on with a counted
                 // legacyInbound warn (the operator watches the tail drain), and
                 // after the window closes it rejects like a failed signature —
                 // N3 proves a NAME's linkability, never key possession.
-                const claim = await verifyOriginClaim(req);
+                // gh#133: the delivery face is where a deposited CLI identity signs its routes.
+                const claim = await verifyOriginClaim(req, { cli: true });
                 if (!claim.ok) {
                     if (claim.reason !== 'absent' || config.originClaimWindow === false) {
                         recordActivity('in', team, caller, false);
@@ -408,6 +513,17 @@ export function registerWireFaces(webServer, d) {
                     }
                     d.bumpLegacyInbound();
                 }
+                // A verified claim proves the caller only when its signed zone covers it (review of PR #134 P1),
+                // and the host face only when it was signed from this very host (round 2: a zone name is not an origin).
+                const callerProof = !claim.ok ? 'legacy-window'
+                    : claim.cli === true ? (claimCovers(caller, claim.caller) ? 'cli-identity' : 'claim-mismatch')
+                        : claim.bound !== true ? 'unbound'
+                            : !isRootOriginUrl(claim.callerUrl) ? 'claim-mismatch'
+                                : admission.rule === 'host-face' && originOf(claim.callerUrl) !== originOf(d.ownCardUrl) ? 'claim-mismatch'
+                                    : claimCovers(caller, claim.caller) ? 'origin-claim' : 'claim-mismatch';
+                const proofClause = callerProof === 'origin-claim' && claim.ok ? `已验证来源 ${originOf(claim.callerUrl)}`
+                    : callerProof === 'cli-identity' ? '未验证（cli-identity）' : `未验证（${callerProof}）`;
+                const directHeader = (from) => `[A2A direct] (task ${taskId}) ${proofClause} ${sanitizeFromClause(from)} (routed to ${team}) sent:`;
                 if (refuseIfBudgetExhausted(req, res, team, caller, taskId, taskLedger))
                     return;
                 // Server-side idempotency (P3/B3): one key, one execution inside
@@ -437,17 +553,29 @@ export function registerWireFaces(webServer, d) {
                 // receipt resolves the task it echoes, whichever wait semantics
                 // carried it here. Correlation is bookkeeping only — the message
                 // steers on exactly as before.
-                settleAndAnnounce(message);
+                // #114 S4: the settler is this delivery's caller, as proven here. A CLI identity's claim URL
+                // is not a host's origin (its origin is unconstrained), so it never vouches for one (review of PR #140 P1-2).
+                // #139: the claim's card key names the host whatever address spelling it signed with.
+                const refusedSettlement = settleAndAnnounce(message, { caller, proof: callerProof, ...settlerClaimFields(claim, originOf), ingress: 'wire' });
+                // #139 (design §4.4): every answer this delivery gets carries the refusal.
+                if (refusedSettlement !== undefined)
+                    withSettlementField(res, refusedSettlement);
                 // gh#45 CLI mailbox (wire face): a delivery targeting a DEPOSITED
                 // CLI handle never resolves a session and never wakes — it lands
                 // in the deposit's mailbox and answers delivered. Placement here
                 // keeps the idempotency claim (above) exactly as for sessions.
                 const cliRow = cliDeposits.get(team);
                 if (cliRow !== undefined) {
-                    cliDeposits.mail(team, caller, message);
+                    cliDeposits.mail(team, caller, `${directHeader(caller)}\n\n${message}`);
                     recordActivity('in', team, caller, true);
                     logger.info(`a2a: cli mailbox delivery for ${team} (from ${caller})`);
-                    const payload = JSON.stringify({ routed: true, delivered: true, receipt: 'mailbox', team, task_id: taskId, task_status: 'TASK_STATE_COMPLETED', note: `delivered to the mailbox of ${team} — the CLI polls while online` });
+                    const note = `delivered to the mailbox of ${team} — the CLI polls while online`;
+                    // gh#112 review: a mailbox delivery is final from this host's
+                    // side, so a resend of this id reads `completed`. A receipt the
+                    // CLI routes back later still reaches its caller, but does not
+                    // replace this outcome (recordOutcome is first-writer-wins).
+                    idempotencyStore.recordOutcome(taskId, { status: 'completed', reply: note });
+                    const payload = JSON.stringify({ routed: true, delivered: true, receipt: 'mailbox', team, task_id: taskId, task_status: 'TASK_STATE_COMPLETED', note });
                     res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
                     res.end(payload);
                     return;
@@ -460,6 +588,18 @@ export function registerWireFaces(webServer, d) {
                 // lookup settles the message is already in — answer delivered and
                 // let the receipt contract carry the reply.
                 if (noWait) {
+                    // gh#112 review P1: a no-wait refusal AFTER the idempotency
+                    // claim records its failed outcome — otherwise a resend of the
+                    // same id reads `pending` from /a2a/query forever and the
+                    // caller is told an undelivered message already landed.
+                    const refuseNoWait = (error, activity = true) => {
+                        if (activity)
+                            recordActivity('in', team, caller, false);
+                        idempotencyStore.recordOutcome(taskId, { status: 'failed', error });
+                        const payload = JSON.stringify({ error, code: -32000, team, task_id: taskId, task_status: 'TASK_STATE_FAILED' });
+                        res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
+                        res.end(payload);
+                    };
                     // Issue #41 companion fix: the no-wait inbound branch resolved
                     // only bare session teams — a canvas team delivery (wait:false)
                     // fell through to the cold tier and answered a bogus
@@ -475,6 +615,11 @@ export function registerWireFaces(webServer, d) {
                         // supplied one (a session node team — wake-on-route covers a
                         // cold one), else the caller label as before.
                         const receiptTarget = callback !== '' ? callback : from;
+                        // gh#112 review: only a failed steer is a refusal. Once the
+                        // message is in the session, a failure in the bookkeeping that
+                        // follows must not record `failed` (a resend would read
+                        // "already ran and failed" and invite a second execution).
+                        let steered = false;
                         try {
                             // The receipt header carries the task id: the target echoes
                             // it verbatim in "[A2A receipt] task <id> ...", closing the
@@ -486,9 +631,16 @@ export function registerWireFaces(webServer, d) {
                             // latched, so the post-steer read alone would answer a false
                             // consumed:true and strand the message.
                             const runningBeforeSteer = probeConsumption(target, taskId);
-                            steerRelay(target, `[A2A direct] (task ${taskId}) ${fromClause(from)} (routed to ${team}) sent:\n\n${message}\n\n(When done, route your outcome back with one call — a2a_route { team: "${receiptTarget}", message: "[A2A receipt] task ${taskId} <one-line outcome>" }.)`, from === 'an unknown node' ? undefined : from);
+                            // #114 S5: the receipt's consumption search starts here, so an
+                            // older steer of a reused id in the history never anchors it.
+                            const steerFloor = eventCountOf(target);
+                            const deliveredReceipt = parseReceipt(message) !== null;
+                            // gh#141: a receipt is answered by nobody — its steer asks for no receipt back.
+                            const receiptRequest = deliveredReceipt ? '' : `\n\n(When done, route your outcome back with one call — a2a_route { team: "${receiptTarget}", message: "[A2A receipt] task ${taskId} <one-line outcome>" }.)`;
+                            steerRelay(target, `${directHeader(from)}\n\n${message}${receiptRequest}`, from === 'an unknown node' ? undefined : from);
+                            steered = true;
                             recordActivity('in', team, caller, true);
-                            armReceiptAutosend(target, taskId, receiptTarget, message);
+                            armReceiptAutosend(target, taskId, receiptTarget, message, steerFloor);
                             // v0.5.23 (async-stall): "delivered" only proves the steer call
                             // returned — not that a turn started. An idle-phase steer wakes
                             // the driver, but a maintenance/abort window latches the wake for
@@ -516,8 +668,28 @@ export function registerWireFaces(webServer, d) {
                             // settle. The row itself stays: stall visibility and the
                             // nudge still apply to the TARGET side.
                             const receiptExpectation = receiptExpectationOf(receiptTarget);
-                            taskLedger.trackInbound(taskId, team, receiptTarget, contextId === '' ? undefined : contextId, receiptExpectation !== 'process-label', briefOf(message));
-                            armAsyncNudge(target, team, taskId, config.asyncNudgeDelayMs);
+                            // #114 S2: the row is born with its immutable authorization record.
+                            const auth = buildAuthorization(admission, {
+                                caller,
+                                proof: callerProof,
+                                ...(claim.ok ? { claim: { caller: claim.caller, origin: originOf(claim.callerUrl) } } : {}),
+                                ingress: 'wire',
+                                allowlistVersion: admittedAt.version,
+                                target: team,
+                                receiptTarget,
+                                receivedAt: admittedAt.at,
+                                // Audit only: a cold session's activation window also reads as running.
+                                targetBusy: runningBeforeSteer,
+                            });
+                            // #139: the member that actually received it answers for a canvas or bare-zone team.
+                            const deliveredTo = sessionTeamOf(target);
+                            // gh#141: a receipt owes no receipt — it is settlement traffic,
+                            // recorded on the row it settled. Booking it would leave a debt
+                            // nothing can pay, and a nudge chasing an answer nobody owes.
+                            if (!deliveredReceipt) {
+                                taskLedger.trackInbound(taskId, team, receiptTarget, contextId === '' ? undefined : contextId, receiptExpectation !== 'process-label', briefOf(message), auth, deliveredTo === team ? undefined : deliveredTo);
+                                armAsyncNudge(target, team, taskId, config.asyncNudgeDelayMs);
+                            }
                             const payload = JSON.stringify({
                                 routed: true,
                                 delivered: true,
@@ -528,16 +700,22 @@ export function registerWireFaces(webServer, d) {
                                 task_status: 'TASK_STATE_DELIVERED',
                                 artifacts: [],
                                 consumed: consumedProbe,
-                                receipt: receiptExpectation === 'process-label' ? 'none' : 'routed',
+                                receipt: receiptExpectation === 'process-label' || deliveredReceipt ? 'none' : 'routed',
                             });
                             res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
                             res.end(payload);
                         }
                         catch (error) {
-                            recordActivity('in', team, caller, false);
-                            const payload = JSON.stringify({ error: `The DSH session rejected the message: ${String(error)}`, code: -32000, team, task_id: taskId, task_status: 'TASK_STATE_FAILED' });
-                            res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
-                            res.end(payload);
+                            if (!steered) {
+                                refuseNoWait(`The DSH session rejected the message: ${String(error)}`);
+                                return;
+                            }
+                            logger.warn(`a2a: task ${taskId.slice(0, 80)} was delivered to ${team}, but its bookkeeping failed: ${String(error)}`);
+                            if (!res.headersSent) {
+                                const payload = JSON.stringify({ routed: true, delivered: true, team, task_id: taskId, context_id: contextId, task_status: 'TASK_STATE_DELIVERED', artifacts: [], consumed: false, receipt: 'routed' });
+                                res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
+                                res.end(payload);
+                            }
                         }
                     };
                     if (agent !== undefined) {
@@ -546,10 +724,7 @@ export function registerWireFaces(webServer, d) {
                     }
                     if (wake?.kind === 'flight') {
                         void wake.flight.then(deliver, (error) => {
-                            recordActivity('in', team, caller, false);
-                            const payload = JSON.stringify({ error: `waking the session for team "${team}" failed: ${String(error)}`, code: -32000, team, task_status: 'TASK_STATE_FAILED' });
-                            res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
-                            res.end(payload);
+                            refuseNoWait(`waking the session for team "${team}" failed: ${String(error)}`);
                         });
                         return;
                     }
@@ -571,34 +746,26 @@ export function registerWireFaces(webServer, d) {
                                     // get an honest failure, never its own dispatch echoed
                                     // home plus an auto-receipt for work nobody did.
                                     if (callerIsAgent(live, caller)) {
-                                        recordActivity('in', team, caller, false);
-                                        const payload = JSON.stringify({ error: selfRouteText(team), code: -32000, team, task_status: 'TASK_STATE_FAILED' });
-                                        res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
-                                        res.end(payload);
+                                        refuseNoWait(selfRouteText(team));
                                         return;
                                     }
                                     deliver(live);
                                     return;
                                 }
                             }
-                            const payload = JSON.stringify({ error: wake?.kind === 'no-face' ? noWakeFaceText(team) : wake?.kind === 'archived' ? archivedColdMatchText(team) : noColdMatchText(team), code: -32000, team, task_status: 'TASK_STATE_FAILED' });
-                            res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
-                            res.end(payload);
+                            refuseNoWait(wake?.kind === 'no-face' ? noWakeFaceText(team) : wake?.kind === 'archived' ? archivedColdMatchText(team) : noColdMatchText(team), false);
                         };
                         const prepared = await nativeTeamsPrepare(team);
                         if (!prepared.ok) {
                             if (prepared.reason === 'error') {
-                                recordActivity('in', team, caller, false);
-                                const payload = JSON.stringify({ error: prepared.error, code: -32000, team, task_status: 'TASK_STATE_FAILED' });
-                                res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
-                                res.end(payload);
+                                refuseNoWait(prepared.error);
                                 return;
                             }
                             standardMiss();
                             return;
                         }
                         recordActivity('in', team, caller, true);
-                        void nativeTeamsRound(prepared, team, caller, message, taskId)
+                        void nativeTeamsRound(prepared, team, caller, message, taskId, proofClause, undefined, (_team, _taskId, from) => directHeader(from))
                             .then(outcome => {
                             if (!outcome.ok) {
                                 recordActivity('in', team, caller, false);
@@ -622,7 +789,7 @@ export function registerWireFaces(webServer, d) {
                     })();
                     return;
                 }
-                void routeIntoAgent(team, message, caller, taskId).then((outcome) => {
+                void routeIntoAgent(team, message, caller, taskId, proofClause, directHeader).then((outcome) => {
                     recordActivity('in', team, caller, outcome.ok);
                     // W7 slice-2 hook 1: record the settled outcome on the claim row.
                     // Ruling: a non-COMPLETED status (TASK_STATE_DELIVERED — the