@nelsonlongxiang/dsh-open-a2a-net 0.7.0 → 0.8.1-preview.1

package/lib/index.js

@@ -46,21 +46,25 @@ import { createDirectForward, ForwardBirths } from "./direct-forward.js";
 import { TeamMembershipStore } from "./team-store.js";
 import { PeerStore } from "./peer-store.js";
 import { SelfReferralFilter } from "./self-suppress.js";
-import { TaskLedger, SUMMARY_CAP, briefOf } from "./task-ledger.js";
+import { TaskLedger, TASK_STALE_TTL_MS, SUMMARY_CAP, briefOf } from "./task-ledger.js";
 import { formatReceipt, parseReceipt, taskIdRefusal } from "./receipt.js";
+import { SuperagentHost } from "./superagent/host/index.js";
+import { registerSuperagentTools } from "./superagent/host/tools.js";
+import { RoleTools } from "./superagent/host/role-tools.js";
 import { ReconciliationReminders } from "./reconciliation-reminders.js";
 import { REMINDER_SCAN_MS, reminderView } from "./reconciliation-state.js";
 import { AdmittedBookkeepingError, ADMITTED_BOOKKEEPING_NOTE } from "./admitted-bookkeeping.js";
+import { FollowupAcceptanceUnknown, ACCEPTANCE_UNKNOWN_NOTE, ACCEPTANCE_INSERTED_NOTE } from "./followup-admission.js";
 import { runReceiptLadder } from "./receipt-ladder.js";
 import { receiptFailure, retryReceiptDelivery, transientReceiptFailure, receiptRetryWait } from "./receipt-retry.js";
-import { IdempotencyStore, WIRE_ERROR_IDEMPOTENCY_CONFLICT, WIRE_ERROR_REPLAY_REJECTED, peerPayloadFingerprint } from "./idempotency-store.js";
+import { IdempotencyStore, WIRE_ERROR_IDEMPOTENCY_CONFLICT, peerPayloadFingerprint } from "./idempotency-store.js";
 import { createFloodGuard } from "./flood-guard.js";
 import { createQueueGuard, queueFullRefusal, QUEUE_FULL_NEXT, WIRE_ERROR_QUEUE_FULL } from "./queue-guard.js";
 import { resolveZone } from "./zone.js";
 import { registerA2aNetworkSkill } from "./skill-registration.js";
 import { isRootOriginUrl, sameMountedUrl, originClaimTeamWarning, signOriginClaim, verifyOriginClaim as verifyOriginClaimOf } from "./origin-claim.js";
 import { AuthObserver } from "./auth-observer.js";
-import { claimCovers, allowlistVersion, authorizationRef, buildAuthorization, callerAdmission, localCandidateAdmission, canonicalAllowlist, judgeSettlement, joinedFaceAdmission, refusalOf, sameZoneAdmission, recheckRemoteCliAuthorization } from "./task-auth.js";
+import { claimCovers, allowlistVersion, authorizationRef, buildAuthorization, callerAdmission, localCandidateAdmission, canonicalAllowlist, judgeSettlement, joinedFaceAdmission, refusalOf, sameZoneAdmission, recheckRemoteCliAuthorization, recheckCallerAdmission } from "./task-auth.js";
 import { MessageId } from '@deepseek-ai/dsh-llm';
 import { FollowupDelivery } from "./followup-delivery.js";
 import { SessionId } from '@deepseek-ai/dsh-session';
@@ -81,16 +85,13 @@ import { registerFileFaces } from "./faces/files.js";
 import { createFileTools } from "./tools/files.js";
 import { BlobStore } from "./blob-store.js";
 import { canvasCandidateMatches, canvasTargetAmbiguous, peerDirectoryRows, routableCallerLabel, sessionCandidateMatches, unroutableCallerNote } from "./peer-directory.js";
-import { createTeamsBridgeInbound } from "./legacy/teams-bridge-inbound.js";
 import { createActTools } from "./tools/act.js";
-import { NATIVE_TEAMS_A2A_FACE_KEY } from "./teams-bridge.js";
 export { A2aClient } from "./a2a-client.js";
-export { NATIVE_TEAMS_A2A_FACE_KEY } from "./teams-bridge.js";
 export const name = 'a2a';
 export const inject = ['tools', 'timer', 'systemPrompt'];
 import { Config } from "./config.js";
 import { canvasOwnerFingerprint, splitCanvasOwner } from "./canvas-id.js";
-import { forwardReceiptBasis } from "./direct-forward.js";
+import { forwardReceiptBasis, teamReceiptBasis } from "./direct-forward.js";
 import { NudgeObservability } from "./nudge-observability.js";
 export { Config };
 /**
@@ -665,7 +666,7 @@ export function apply(ctx, config) {
     }
     /**
      * Settle one message through the ledger and announce what it correlated
-     * on `a2a/receipt-resolved` — the seam peer plugins (native-teams)
+     * on `a2a/receipt-resolved` — the seam peer plugins
      * consume to settle their outstanding async submissions. Fence honesty:
      * the try/catch contains SYNCHRONOUS listener throws (cordis dispatch is
      * synchronous, so a throw lands here and the routing path survives); an
@@ -696,6 +697,11 @@ export function apply(ctx, config) {
         // (enforce): that is the verdict — the echo fallback must not judge the
         // same message a second time.
         const owedRow = parsed !== null && parsed.taskId !== '' ? taskLedger.find(parsed.taskId) : undefined;
+        // p1-mailbox-owes (S33, a): a row owed by a CLI identity on this host (the inbound row an owing deposit keeps, or a
+        // same-host caller's local row) is answered by that identity alone — keyed on the row, so it holds after the deposit
+        // lapses too. A receipt header from anyone else names it without touching it: no settlement, no echo, no outcome.
+        if (owedRow !== undefined && (owedRow.direction === 'inbound' || owedRow.peer === 'local') && CLI_HANDLE_RE.test(owedRow.team) && settler?.caller !== owedRow.team)
+            return undefined;
         const owedByHeader = owedRow !== undefined;
         // #139 (design §4.4): an enforce refusal of the row the header names is
         // told to the sender on the wire response, not only in /state.
@@ -703,6 +709,15 @@ export function apply(ctx, config) {
         // Capture authority while the owed row is still present; successful resolve archives it.
         const outcomeAllowed = judge?.enforce !== true || (owedRow !== undefined && headerVerdict?.ok === true);
         const resolved = taskLedger.resolveFromMessage(message, judge);
+        // An acknowledgement marks the owed row and settles nothing: no waiter is answered, no outcome is recorded, and the
+        // settlement seam is not told (its consumers treat a resolution as the end of the task).
+        if (parsed?.envelope?.disposition === 'acknowledged') {
+            if (resolved?.acknowledged === true)
+                logger.info(`a2a: task ${resolved.taskId} acknowledged by its target; it stays owed until the result`);
+            return undefined;
+        }
+        if (resolved !== undefined)
+            pruneReceiptWaiters();
         if (parsed !== null && parsed.taskId !== '') {
             const line = parsed.summary.trim();
             // #114 S4 (design §4.2.2): under enforce, the receipt hook writes the
@@ -726,6 +741,7 @@ export function apply(ctx, config) {
             // settles. Formal receipt headers keep observing; settlementAuth 'off' still judges nothing.
             const echoed = taskLedger.resolveEcho(message, judge !== undefined && !judge.enforce ? { ...judge, enforce: true } : judge);
             if (echoed.length > 0) {
+                pruneReceiptWaiters();
                 logger.info(`a2a: ${String(echoed.length)} pending task(s) settled by content echo (${echoed.join(', ')})`);
             }
             return undefined;
@@ -760,7 +776,12 @@ export function apply(ctx, config) {
             return true;
         try {
             const settled = taskLedger.resolveFromMessage(message, settlementJudgeFor(payer, parsed, true), row => row.direction === 'inbound' && row.peer === `local:${creditor}`);
+            // An acknowledgement only marks the row it was born with (it stays owed until the result).
+            if (settled?.acknowledged === true)
+                return true;
             const line = parsed.summary.trim();
+            if (settled !== undefined)
+                pruneReceiptWaiters();
             if (settled !== undefined && line !== '')
                 idempotencyStore.recordOutcome(parsed.taskId, { status: 'completed', reply: line.slice(0, SUMMARY_CAP) });
             return true;
@@ -790,6 +811,22 @@ export function apply(ctx, config) {
     // Live top-level agents: the join surface's candidates and the cold-row
     // complement (apply scope — the direct-route wake below reads it too).
     const liveRoots = new Map();
+    /**
+     * The agent preset a live session runs (the preset registry's inspection of its exact revision); undefined when the
+     * session is not loaded or the host has no preset registry.
+     */
+    const sessionPresetOf = (id) => {
+        const agent = liveRoots.get(id);
+        const presets = ctx.get('agentPresets');
+        if (agent === undefined || presets?.inspectCompositions === undefined)
+            return undefined;
+        try {
+            return presets.inspectCompositions(agent.ctx)[0]?.id;
+        }
+        catch {
+            return undefined;
+        }
+    };
     // Node identity N2+N3: a joined session that carries a node gets that node's layers on its own scope.
     const nodeBindings = new NodeBindings(join(home, 'a2a'));
     const nodeReviews = new NodeReviewQueue(join(home, 'a2a'));
@@ -1676,6 +1713,8 @@ export function apply(ctx, config) {
                 nudgeEscalations: () => nudgeObservations.snapshot(),
                 ctx, config, logger, home, session, lanIp, PLUGIN_VERSION, controlRoute, controlTrustedWithoutKey, readJsonBody, peerFetch, peerStore, peerLinkState, originClaimHeaders, refreshRemoteRows, joinedSessions, exposureStore, teamMemberships, cliDeposits, groupStore, canvasStore, revokeCanvasMember, canvasMigrationState, canvasMemberForWrite, cliHomeForAdd, cliHomeOptions, layoutStore, taskLedger, idempotencyStore, inFlightRoutes, recentActivity, teamAuditRing, reportRing, sessionNodes, liveRoots, mountSessionNode, coldJoinedIds, prewarmStatus, reconcileStatus, id8, sessionLabelOf, sessionTeamOf, ownCanvasHandleOf, localSessionOfHandle, canvasTeamsOfSession, nodeMetadataOf, canvasTeamOf, archivedSessionFilter, pruneArchivedJoins, pruneCanvasMemberships, verifyOriginClaim, callerLinkedToThisHost, cachedCardFetch, authorizationView,
                 indexUrl: import.meta.url, enforceRefused,
+                teamCanvasRefusal: (canvas, member) => superagentHost?.canvasMemberRefusal(canvas, member, sessionPresetOf),
+                admissionRecheck: (caller, handle, local) => recheckCallerAdmission(linkRecheckRecords, caller, handle, local),
                 get cardCache() { return cardCache; },
                 get remoteRowsCache() { return remoteRowsCache; },
                 get legacyInboundCount() { return legacyInboundCount; },
@@ -1836,7 +1875,7 @@ export function apply(ctx, config) {
                         // gh#152: members are read through the local tiers' lens — one of
                         // this host's own handles resolves to the session it names, and
                         // the two stored shapes of one session publish as ONE handle.
-                        ...(named ? { canvasOrg: canvasStore.list().map(name => ({ name, team: canvasTeamOf(name), members: [...new Set(canvasLocalMembersOf(name))].map(id => sessionNodes.has(id) || joinedSessions.has(id) ? `${config.team}/${id8(id)}` : id) })) } : {}),
+                        ...(named ? { canvasOrg: canvasStore.list().map(name => ({ name, team: canvasTeamOf(name), members: [...new Set(canvasLocalMembersOf(name))].map(id => sessionNodes.has(id) || joinedSessions.has(id) ? `${config.team}/${id8(id)}` : id), ...(superagentHost?.a2aAddress !== undefined && superagentHost.settings.canvas === name ? { superagentTeam: true } : {}) })) } : {}),
                         ...(named && lanIp !== '' ? { lanIp } : {}),
                         ...(PLUGIN_VERSION !== '' ? { version: PLUGIN_VERSION } : {}),
                         description: `A2A node exposing team ${config.team}${named ? '' : ' (minimal card — OriginClaim envelope required for the full card: X-A2A-Caller/-Url/-Ts/-Sig signed with your card key)'}`,
@@ -1895,12 +1934,216 @@ export function apply(ctx, config) {
         warn: code => logger.warn('a2a: sourced followup (%s); check ledger persistence and original task', code),
     });
     const followupRelay = (agent, text, sender, localFrom, taskId, callerKey, taskExpected = true) => followupDelivery.deliver(agent, text, sender, localFrom, taskId, callerKey, taskExpected);
+    // superagent design v4, PR-B: superagent's domain engine in this host (off unless config.superagent). The router gets
+    // candidate cards in its own session (host relay, not A2A) and decides only through the superagent_* tools.
+    const superagentHost = config.superagent === true ? new SuperagentHost({
+        home: join(home, 'a2a'), logger,
+        deliverToSession: (id, text) => { const agent = sessionNodes.get(id); if (agent === undefined)
+            return false; followupRelay(agent, text, config.team); return true; },
+        interval: (fn, ms) => ctx.timer.interval(fn, ms),
+        // The team's A2A address (PR-B2b) is a CLI identity the a2a-net CLI runs against this very host.
+        homeUrl: () => superagentHomeUrl,
+        apiKey: () => config.apiKey,
+        // PR-C2: remote members and served teams talk host to host, signed with this host's card key and bound to the body.
+        signedPost: async (baseUrl, path, body) => {
+            const target = baseUrl.replace(/\/$/, '') + path;
+            const text = JSON.stringify(body);
+            const reply = await peerFetch(target, { method: 'POST', headers: { 'Content-Type': 'application/json', ...originClaimHeaders({ url: target, method: 'POST', body: text }) }, body: text, signal: AbortSignal.timeout(15_000) });
+            if (!reply.ok) {
+                void reply.body?.cancel().catch(() => { });
+                return { ok: false, status: reply.status, error: `HTTP ${String(reply.status)}` };
+            }
+            try {
+                return JSON.parse(await reply.text());
+            }
+            catch {
+                return { ok: false, error: 'not JSON' };
+            }
+        },
+        handleOf: id => `${config.team}/${id8(id)}`,
+        localSessionOf: handle => localSessionOfHandle(handle),
+        onRolesChanged: () => { syncRoleTools(); },
+        // Design v5: the team is a canvas team this host owns. Its local sessions in canvas order, and its remote session slots
+        // with the key the canvas pinned and the base URL of the linked peer whose signed card carries that key.
+        canvasTeam: name => {
+            if (!canvasStore.hasTeam(name))
+                return undefined;
+            const ownKey = encodePublicKey(createPublicKey(nodePrivateKey));
+            const local = canvasLocalMembersOf(name, true).filter(id => !id.includes('/'));
+            const remote = canvasStore.membersOf(name).flatMap(ref => {
+                if (CLI_HANDLE_RE.test(ref) || splitQualifiedMember(ref) === undefined)
+                    return [];
+                const key = canvasStore.ownerKeyOf(ref);
+                if (key === undefined || key === ownKey || memberProvenance(ref, key, ownKey) !== 'confirmed-remote')
+                    return [];
+                const url = [...cardCache.entries()].find(([, entry]) => entry.card?.publicKey === key)?.[0];
+                return [{ ref, key, url: url !== undefined ? new URL(url).origin : '' }];
+            });
+            return { local, remote };
+        },
+        canvasesOf: id => canvasTeamsOfSession(id),
+        canvasNames: () => canvasStore.list(),
+        presetOf: id => sessionPresetOf(id),
+        cancelTurn: id => {
+            const agent = sessionNodes.get(id);
+            if (agent === undefined || agent.status === 'idle' || typeof agent.cancel !== 'function')
+                return false;
+            agent.cancel({ kind: 'user' }, { keepInbox: false });
+            return true;
+        },
+        memberTurn: id => {
+            const agent = sessionNodes.get(id);
+            if (agent === undefined)
+                return undefined;
+            const jobs = ctx.get('jobs');
+            const quiet = !(jobs?.list?.(id) ?? []).some(job => job.owner === id && (job.status === 'running' || job.status === 'stopping'));
+            const last = [...sessionEventsOf(agent)].reverse().find(event => event?.type === 'assistant/message');
+            return { quiet, text: (last?.data?.message?.content ?? []).filter(block => block.type === 'text').map(block => block.text ?? '').join('\n').trim() };
+        },
+        teamSend: args => teamCanvasSend(args),
+    }) : undefined;
+    // PR-D: the router and the members call only their role's tools — a host guard, whatever preset the session runs.
+    const superagentRoleTools = new RoleTools({
+        roleOf: id => superagentHost?.roleOf(id),
+        agentOf: id => ctx.get('agents')?.get(SessionId(id)),
+        logger,
+    });
+    function syncRoleTools() { for (const agent of liveRootAgents(ctx.get('agents')))
+        superagentRoleTools.sync(agent); }
+    let superagentHomeUrl;
+    if (superagentHost !== undefined) {
+        whenWebServerSettled(webServer => { superagentHomeUrl = `http://127.0.0.1:${String(webServer.port)}`; });
+        ctx.effect(() => { superagentHost.start(); return () => { void superagentHost.stop(); }; }, 'a2a: superagent engine passes');
+        registerSuperagentTools(ctx, () => superagentHost);
+        // A member's turn ending is the executor's turn-end fact (PR-C1).
+        ctx.on('agent/status', payload => { if (payload.status === 'idle')
+            superagentHost.memberIdle(String(payload.agent.id)); });
+        // A failed turn is retried or fails the ticket for a person (upstream); without this it read as still working.
+        ctx.on('agent/error', ({ agent, error }) => { superagentHost.memberFailed(String(agent.id), error); });
+        // PR-F: an Input counts as read once the member's session takes the message carrying it into its history.
+        ctx.on('agent/inbox/claimed', ({ agent }) => { superagentHost.memberClaimed(String(agent.id)); });
+        ctx.tools.guard(exec => {
+            const refusal = superagentRoleTools.guard(exec.name, exec.agent);
+            if (refusal !== undefined)
+                superagentHost.noteRefusal('superagent-role-tools', { ...(exec.agent !== undefined ? { caller: String(exec.agent.id) } : {}), target: exec.name });
+            return refusal;
+        });
+        ctx.on('agent/created', ({ agent }) => { superagentRoleTools.sync(agent); return undefined; });
+        ctx.on('agent/disposed', ({ agent }) => { superagentRoleTools.forget(String(agent.id)); });
+        syncRoleTools();
+    }
+    /**
+     * The router acts only through superagent tools and takes work only as candidates from the team's Sources, so A2A
+     * neither reaches it nor leaves it (hard rule, every route seam).
+     * @returns the refusal, or undefined when the router is not involved.
+     */
+    function superagentRouterRefusal(callerSessionId, target) {
+        const refusal = superagentRefusalText(callerSessionId, target);
+        // Every caller returns this refusal to the route it refused, so each refused route counts once (PR-F: acceptance item 7).
+        if (refusal !== undefined)
+            superagentHost?.noteRefusal(/^\[([a-z-]+)\]/.exec(refusal)?.[1] ?? 'superagent', { ...(callerSessionId !== undefined ? { caller: callerSessionId } : {}), target });
+        return refusal;
+    }
+    function superagentRefusalText(callerSessionId, target) {
+        if (superagentHost === undefined)
+            return undefined;
+        const callerRole = callerSessionId === undefined ? undefined : superagentHost.roleOf(callerSessionId);
+        if (callerRole === 'router')
+            return '[superagent-router-outbound] the team router does not route A2A; it decides with superagent_route and replies with superagent_reply';
+        if (callerRole === 'member')
+            return '[superagent-member-outbound] a team member does not route A2A; it works on its assigned ticket and reports with a2a_ticket_report';
+        const bare = target.replace(/@[0-9a-f]{8}$/, '');
+        const named = (id) => { const handle = `${config.team}/${id8(id)}`; return target === id || (bare === handle && (target === bare || target.endsWith('@' + ownCanvasFingerprint))); };
+        const router = superagentHost.routerSession;
+        if (router !== undefined && named(router))
+            return '[superagent-router-inbound] the team router takes no A2A work; send requests to the team\'s Sources (the workbench or its A2A address), where the gate admits them';
+        if (superagentHost.settings.members.some(named))
+            return '[superagent-member-inbound] a team member takes work only as assignments from the team\'s executor; send requests to the team\'s Sources';
+        return undefined;
+    }
+    /**
+     * Design v5 (D2): the team's address is its canvas team. A route to the bound canvas — bare, or qualified with this
+     * host's own fingerprint — lands in the team's mailbox (the A2A Source reads it), never in a member session.
+     */
+    function teamMailboxOf(team) {
+        const bound = superagentHost?.settings.canvas;
+        const address = superagentHost?.a2aAddress;
+        if (bound === undefined || address === undefined)
+            return undefined;
+        const split = splitCanvasOwner(team.trim());
+        if (split.owner !== undefined && split.owner !== ownCanvasFingerprint)
+            return undefined;
+        return split.team === `${config.team}/canvas/${bound}` ? address : undefined;
+    }
+    /** Design v5 (D2): a route straight to the team identity's handle is refused (a receipt to it still lands): the address is the canvas. */
+    function teamAddressRefusal(team, message) {
+        const address = superagentHost?.a2aAddress;
+        if (address === undefined || team.trim() !== address || parseReceipt(message) !== null)
+            return undefined;
+        const bound = superagentHost?.settings.canvas;
+        superagentHost?.noteRefusal('superagent-team-address', { target: team });
+        return `[superagent-team-address] ${address} is the team's internal mailbox; send requests to the team's canvas address${bound !== undefined ? ` ${config.team}/canvas/${bound}` : ' (the team is bound to no canvas team yet)'}`;
+    }
+    /**
+     * Design v5 (D2, review R1): the team's own messages to a requester that came through its canvas address — the formal
+     * receipt (result, attention or acknowledgement) and follow-ups in the same conversation — go out from this host's
+     * process face on the canvas team's behalf, with onBehalfOf spelled exactly as the requester addressed it, so the
+     * requester's ledger settles them as host-face. Speaks the a2a-net CLI's `receipt` / `route` JSON contract (stdout, exit
+     * codes 4 gone / 5 another receipt) for the A2A Source; undefined when the task did not come through the canvas.
+     */
+    async function teamCanvasSend(args) {
+        const verb = args[0];
+        if (verb !== 'receipt' && verb !== 'route')
+            return undefined;
+        const dash = args.indexOf('--');
+        const text = dash >= 0 ? args.slice(dash + 1).join(' ') : '';
+        const flagOf = (name) => { const i = args.indexOf(name); return i >= 0 && (dash < 0 || i < dash) ? args[i + 1] : undefined; };
+        const fail = (code, error) => { const e = new Error(error); e.exitCode = code; throw e; };
+        if (verb === 'receipt') {
+            const task = args[1] ?? '', to = flagOf('--to') ?? '';
+            const row = taskLedger.find(task);
+            if (row === undefined || teamMailboxOf(row.team) === undefined || to === '')
+                return undefined;
+            // Review of #442: switches are read before `--` only — the text after it may be anything.
+            const switches = dash >= 0 ? args.slice(0, dash) : args;
+            const acknowledged = switches.includes('--acknowledged'), attention = switches.includes('--attention');
+            const outcome = flagOf('--outcome');
+            const fields = acknowledged ? { idempotencyKey: task, disposition: 'acknowledged', onBehalfOf: row.team }
+                : attention ? { idempotencyKey: task, disposition: 'attention', onBehalfOf: row.team }
+                    : { outcome: (outcome ?? 'completed'), idempotencyKey: task, disposition: 'result', onBehalfOf: row.team };
+            const receipt = formatReceipt(task, text.replace(/\s+/g, ' ').trim(), fields);
+            const receiptTask = `${acknowledged ? 'ack' : 'receipt'}-${task}`;
+            try {
+                const out = await dispatchAnywhere(to, receipt, session, row.contextId, new AbortController().signal, true, receiptTask);
+                // This host's own inbound row (a requester on another host or a CLI here): the receipt it sent settles it.
+                if (row.direction === 'inbound' && !acknowledged)
+                    settleOwnInbound(receipt, to, { caller: session, proof: 'in-process', ingress: 'local' });
+                return JSON.stringify({ delivered: true, class: 'sent', task_id: receiptTask, team: to, ...(typeof out.context_id === 'string' ? { context_id: out.context_id } : {}) });
+            }
+            catch (error) {
+                const code = error.code;
+                return fail(code === WIRE_ERROR_IDEMPOTENCY_CONFLICT ? 5 : 1, String(error instanceof Error ? error.message : error));
+            }
+        }
+        const to = args[1] ?? '', context = flagOf('--context') ?? '', followTask = flagOf('--task');
+        const origin = taskLedger.list().find(r => r.contextId === context && teamMailboxOf(r.team) !== undefined);
+        if (origin === undefined || to === '')
+            return undefined;
+        try {
+            await dispatchAnywhere(to, text, session, context, new AbortController().signal, true, followTask);
+            return JSON.stringify({ delivered: true, class: 'sent', ...(followTask !== undefined ? { task_id: followTask } : {}), team: to, context_id: context });
+        }
+        catch (error) {
+            return fail(1, String(error instanceof Error ? error.message : error));
+        }
+    }
     ctx.on('agent/inbox/claimed', ({ agent, message }) => followupDelivery.claimed(agent, String(message.id)));
     const withdrawQueuedTask = (taskId) => {
         const controller = ctx.get('sessionController');
         return followupDelivery.withdraw(taskId, controller, id => ctx.get('agents')?.get(SessionId(id)));
     };
     const cancelQueuedTask = async (taskId, text, sender, original) => {
+        pruneReceiptWaiters();
         let record, withdrawFailed = false, removed = false;
         try {
             record = taskLedger.deliveryFor(taskId);
@@ -2026,6 +2269,9 @@ export function apply(ctx, config) {
         }
     };
     function armAsyncNudge(agent, team, taskId, delayMs) {
+        // asyncNudgeDelayMs 0 (or less) turns the nudge off, as the config schema and README promise (#453).
+        if (!(delayMs > 0))
+            return;
         const key = String(agent.id);
         const spent = nudgeBudget.get(key);
         if (spent !== undefined && spent > 1)
@@ -2127,6 +2373,13 @@ export function apply(ctx, config) {
         // target produced after consuming `[A2A direct] (task <id>)` answers it
         // (flushFinals). A busy target's other work line can no longer settle
         // a task it has not read yet (the #61 direct-bb27ec94 shape).
+        // Defensive only: no current normal replay/reentry path reaches a second
+        // registration. Both wire sites follow the idempotency claim; local tools
+        // mint an id per call, background notices mint one, and receipt retries keep
+        // their id but exit above (receipts owe no receipts). No present-path mutation
+        // coverage claim: this check guards future/internal callers, not replay admission.
+        if ((pendingFinals.get(String(target.id)) ?? []).some(entry => entry.purpose === 'receipt' && entry.taskId === taskId))
+            return;
         registerFinalWaiter(target, (finalText, placeholder) => {
             // W7 slice-2: a host-authored placeholder (flush timeout, dead
             // session) must not synthesize a COMPLETION receipt — a wedged
@@ -2173,7 +2426,9 @@ export function apply(ctx, config) {
             /* Legacy permanent-failure ladder remains the owner-settlement policy. */
             const ladder = () => runReceiptLadder({
                 deliver: deliverReceipt,
-                transient: transientReceiptFailure,
+                // Unknown admission must stop the owner lane; unlike a transport transient,
+                // it is not retryable by retryReceiptDelivery and retains the original debt.
+                transient: error => error instanceof FollowupAcceptanceUnknown || transientReceiptFailure(error),
                 ownerTeam: config.team,
                 log: (stage, error) => {
                     // N2 (observability): throttled per task to avoid ping-pong noise.
@@ -2190,10 +2445,10 @@ export function apply(ctx, config) {
                 notify: async () => { await dispatchAnywhere(config.team, '[A2A receipt delivery notice] ref ' + nudgeRef(taskId) + '; delivery to the original caller is temporarily unconfirmed; host retry is responsible. This notice is not a receipt and does not settle work.', session, undefined, new AbortController().signal, true); },
                 pending: () => row === undefined || taskLedger.isPending(taskId), wait, log: () => { logger.warn('a2a: receipt delivery temporarily unconfirmed ref=%s', nudgeRef(taskId)); },
             }).catch(() => { });
-        }, { taskId, steerFloor });
+        }, { taskId, steerFloor }, 'receipt');
     }
     /**
-     * Register one final-reply waiter for the agent and arm its flush timeout.
+     * Register one attributed waiter: HTTP has a flush window, receipt tracking the original task TTL.
      * @param agent - the agent whose next assistant message answers the waiter.
      * @param answer - how the waiter's reply is delivered.
      * @param attribution - #114 S5: attribute by consumption — only the turn
@@ -2203,14 +2458,20 @@ export function apply(ctx, config) {
      *   anchors it.
      * @returns the registered waiter (for callers that may retract it).
      */
-    function registerFinalWaiter(agent, answer, attribution) {
+    function registerFinalWaiter(agent, answer, attribution, purpose = 'http') {
         const key = String(agent.id);
         const waiter = {
-            answer,
+            answer, purpose,
             sinceEvents: sessionEventsOf(agent).length,
             ...(attribution !== undefined && attribution.taskId !== '' ? { taskId: attribution.taskId, scannedTo: attribution.steerFloor } : {}),
         };
-        waiter.timeoutDisposer = armFlushTimeout(key, waiter);
+        if (purpose === 'receipt') {
+            const row = attribution === undefined ? undefined : taskLedger.find(attribution.taskId);
+            const remaining = Math.max(0, (row?.startedAt ?? Date.now()) + (config.taskStaleTtlMs ?? TASK_STALE_TTL_MS) - Date.now());
+            waiter.timeoutDisposer = ctx.timer.timeout(() => removeFinalWaiter(key, waiter), remaining);
+        }
+        else
+            waiter.timeoutDisposer = armFlushTimeout(key, waiter);
         pendingFinals.set(key, [...(pendingFinals.get(key) ?? []), waiter]);
         return waiter;
     }
@@ -2232,22 +2493,6 @@ export function apply(ctx, config) {
         if (wake.kind === 'flight') {
             return wake.flight.then(agent => routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered, callerKey), (error) => ({ ok: false, error: `waking the session for team "${team}" failed: ${String(error)}` }));
         }
-        // Native-teams inbound bridge (opt-in): a registry team claims the
-        // handle and dispatches through its authoritative seam. Checked before
-        // the bare-team fallback — a team named exactly like this node's team
-        // resolves to the registry's claim, not the initiator redirect.
-        if (config.nativeTeamsInbound === true) {
-            const prepared = await nativeTeamsPrepare(team);
-            if (prepared.ok) {
-                const bridged = await nativeTeamsRound(prepared, team, caller, message, taskId, proofClause ?? '未验证（in-process）', undefined, buildHeader === undefined ? undefined : (_team, _taskId, from) => buildHeader(from));
-                if (bridged.ok) {
-                    if (bridged.settled)
-                        return { ok: true, reply: bridged.reply };
-                    return { ok: true, reply: bridged.reply, status: 'TASK_STATE_DELIVERED', bridge: 'native-teams' };
-                }
-                return { ok: false, error: bridged.error };
-            }
-        }
         // Only the bare process team falls back to the live (initiator) agent.
         // A session-node-shaped team that misses is an error, never a silent
         // redirect: a mistyped or stale short id must not reach another session
@@ -2275,6 +2520,10 @@ export function apply(ctx, config) {
      * @returns the agent's final reply, or the explicit failure.
      */
     function routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered, callerKey) {
+        // superagent v4: whatever address resolved to it (a canvas team, the node team), the router takes no A2A work.
+        if (superagentHost?.roleOf(String(agent.id)) !== undefined) {
+            return Promise.resolve({ ok: false, error: superagentRouterRefusal(undefined, String(agent.id)) ?? 'superagent team sessions take no A2A work' });
+        }
         return new Promise((resolve) => {
             // #306: synchronous replies use the same reading-turn attribution as automatic receipts.
             // Registering and steering are synchronous, so this is the exact pre-steer floor.
@@ -2309,8 +2558,13 @@ export function apply(ctx, config) {
             const text = `${headerLine}\n\n${message}`;
             try {
                 const floor = sessionEventsOf(agent).length;
-                followupRelay(agent, text, caller === '' ? undefined : caller, localFrom, taskId, callerKey, onSteered !== undefined);
-                onSteered?.(agent, floor);
+                const acceptance = followupRelay(agent, text, caller === '' ? undefined : caller, localFrom, taskId, callerKey, onSteered !== undefined);
+                onSteered?.(agent, floor, acceptance);
+                if (acceptance === 'inserted') {
+                    removeFinalWaiter(String(agent.id), waiter);
+                    resolve({ ok: true, reply: ACCEPTANCE_INSERTED_NOTE, acceptance, placeholder: true });
+                    return;
+                }
                 admissionFinished = true;
                 if (earlyReply)
                     resolve(earlyReply);
@@ -2332,15 +2586,14 @@ export function apply(ctx, config) {
                     resolve({ ok: true, reply: ADMITTED_BOOKKEEPING_NOTE, receiverBookkeeping: 'failed', placeholder: true });
                     return;
                 }
+                if (error instanceof FollowupAcceptanceUnknown) {
+                    resolve({ ok: false, error: ACCEPTANCE_UNKNOWN_NOTE, acceptance: 'unknown' });
+                    return;
+                }
                 resolve({ ok: false, error: `The DSH session rejected the message: ${String(error)}` });
             }
         });
     }
-    // gh#77 G-in (S23 repayment): the native-teams inbound bridge moved verbatim
-    // to src/legacy/teams-bridge-inbound.ts — the registry probe, claim memo,
-    // prepare and the bounded round. The outbound bridgeFace stays here until
-    // the G-out slice (it submits through the dispatch trunk).
-    const { teamsRegistry, nativeTeamsClaims, nativeTeamsPrepare, nativeTeamsRound } = createTeamsBridgeInbound({ ctx, config, liveAgent, fromClause, sanitizeFromClause, proofHeader: hostDirectHeader, taint: agent => { markLineage(agent, 'native-teams'); } });
     /* ── gh#9+gh#10 OriginClaim (docs/protocol/delivery-origin-auth.md,
        src/origin-claim.ts): the caller's card key signs the envelope; the
        bound form must name one of OUR origins and the route it hits. ts skew
@@ -2608,6 +2861,21 @@ export function apply(ctx, config) {
         cliDeposited: handle => cliDeposits.get(handle) !== undefined,
         cliHomeOf: handle => canvasStore.cliHomeOf(handle),
     };
+    /**
+     * v5-B2: an identity's `admission` query rechecks a caller it already took (its key was verified when the delivery came
+     * in): only that the operator's link still stands. A confirmed canvas remote reference pinned with its key is that link
+     * for the bare handle too — the delivery-time records match a qualified reference only under the signer's key, which a
+     * recheck does not carry.
+     */
+    const linkRecheckRecords = {
+        ...admissionRecords,
+        canvasRemoteMembersOf: name => canvasStore.remoteMembersOf(name).flatMap(ref => {
+            const qualified = splitQualifiedMember(ref);
+            if (qualified === undefined)
+                return [ref];
+            return memberProvenance(ref, canvasStore.ownerKeyOf(ref), encodePublicKey(createPublicKey(nodePrivateKey))) === 'confirmed-remote' ? [ref, qualified.handle] : [ref];
+        }),
+    };
     /** W1/W2 shared-team admission (see sameZoneAdmission in src/task-auth.ts). */
     function sameZoneSharedTeamRefusal(caller, targetTeam) {
         return refusalOf(sameZoneAdmission(admissionRecords, caller, targetTeam));
@@ -2731,38 +2999,45 @@ export function apply(ctx, config) {
        identical semantics — artifact existence is the only gate (archived
        and never-joined sessions stay readable), caps mirror
        session-transcript.ts. */
+    /** `dshHome` may move only the plugin's own state, with the host still writing session logs under its own home. */
+    function sessionLogRoots() {
+        const own = join(home, 'sessions');
+        const root = existsSync(own) ? own : join(resolveDshHome(), 'sessions');
+        return existsSync(root) ? [root] : [];
+    }
     function scanSessionLogList() {
         const rows = [];
-        const sessionsRoot = join(home, 'sessions');
-        if (!existsSync(sessionsRoot))
-            return rows;
-        for (const bucket of readdirSync(sessionsRoot, { withFileTypes: true })) {
-            if (!bucket.isDirectory())
-                continue;
-            for (const child of readdirSync(join(sessionsRoot, bucket.name), { withFileTypes: true })) {
-                if (!child.isDirectory())
-                    continue;
-                const dir = join(sessionsRoot, bucket.name, child.name);
-                const files = readdirSync(dir).filter(name => name.startsWith('session.') && (name.endsWith('.jsonl.zstd') || name.endsWith('.jsonl')));
-                if (files.length === 0)
+        const seen = new Set();
+        for (const sessionsRoot of sessionLogRoots()) {
+            for (const bucket of readdirSync(sessionsRoot, { withFileTypes: true })) {
+                if (!bucket.isDirectory())
                     continue;
-                let newest;
-                for (const name of files) {
-                    const st = statSync(join(dir, name));
-                    if (newest === undefined || st.mtimeMs > newest.mtimeMs)
-                        newest = { mtimeMs: st.mtimeMs, sizeBytes: st.size };
+                for (const child of readdirSync(join(sessionsRoot, bucket.name), { withFileTypes: true })) {
+                    if (!child.isDirectory() || seen.has(child.name))
+                        continue;
+                    const dir = join(sessionsRoot, bucket.name, child.name);
+                    const files = readdirSync(dir).filter(name => name.startsWith('session.') && (name.endsWith('.jsonl.zstd') || name.endsWith('.jsonl')));
+                    if (files.length === 0)
+                        continue;
+                    let newest;
+                    for (const name of files) {
+                        const st = statSync(join(dir, name));
+                        if (newest === undefined || st.mtimeMs > newest.mtimeMs)
+                            newest = { mtimeMs: st.mtimeMs, sizeBytes: st.size };
+                    }
+                    if (newest !== undefined) {
+                        seen.add(child.name);
+                        rows.push({ id: child.name, ...newest });
+                    }
                 }
-                if (newest !== undefined)
-                    rows.push({ id: child.name, ...newest });
             }
         }
         rows.sort((a, b) => b.mtimeMs - a.mtimeMs);
         return rows;
     }
     function readSessionLogTail(id, limit) {
-        const sessionsRoot = join(home, 'sessions');
         let logPath;
-        if (existsSync(sessionsRoot)) {
+        search: for (const sessionsRoot of sessionLogRoots()) {
             for (const entry of readdirSync(sessionsRoot, { withFileTypes: true })) {
                 if (!entry.isDirectory())
                     continue;
@@ -2777,7 +3052,7 @@ export function apply(ctx, config) {
                 const rank = (name) => generation(name) * 2 + (name.endsWith('.zstd') ? 1 : 0);
                 files.sort((a, b) => rank(b) - rank(a));
                 logPath = files[0] !== undefined ? join(candidate, files[0]) : undefined;
-                break;
+                break search;
             }
         }
         if (logPath === undefined)
@@ -2795,6 +3070,12 @@ export function apply(ctx, config) {
             config,
             cliDeposits,
             canvasStore, canvasMemberForWrite,
+            teamCanvasRefusal: (canvas, member) => superagentHost?.canvasMemberRefusal(canvas, member, sessionPresetOf),
+            teamCanvasBound: (canvas) => superagentHost?.settings.canvas === canvas,
+            superagentInbound: team => superagentRouterRefusal(undefined, team),
+            superagentIntake: team => superagentHost?.a2aAddress === team,
+            teamMailboxOf: team => teamMailboxOf(team),
+            teamAddressRefusal: (team, message) => teamAddressRefusal(team, message),
             canvasNameReserved: name => canvasNameReserved(name, config.team, ownerAllowlist, teamMemberships),
             sessionNodes,
             joinedSessions,
@@ -2803,6 +3084,7 @@ export function apply(ctx, config) {
             peerKeyAdmits,
             remoteCliProof,
             forwardReceiptBasis: (taskId, caller, cliHandle, claim) => forwardReceiptBasis(taskLedger.find(taskId), caller, cliHandle, claim),
+            teamReceiptBasis: (taskId, caller, target, onBehalfOf, claim) => teamReceiptBasis(taskLedger.find(taskId), caller, target, onBehalfOf, claim),
             forwardDirect: request => forwardDirect(request), ownCanvasFingerprint,
             diagnoseCanvas: (team, reason, caller) => diagnoseCanvas(team, reason, caller),
             callerLinkedToThisHost, get ownCardUrl() { return ownCardUrl; },
@@ -2852,11 +3134,162 @@ export function apply(ctx, config) {
             noWakeFaceText,
             archivedColdMatchText,
             noColdMatchText,
-            nativeTeamsPrepare,
-            nativeTeamsRound,
             routeIntoAgent,
         });
     });
+    if (superagentHost !== undefined)
+        whenWebServerSettled((webServer) => {
+            // superagent design v4, PR-B: the owner's workbench face of the engine (owner control route only).
+            // GET: the engine state; POST: settings (router, allowed senders, Sources, pause), request (the workbench Source),
+            // stop / retry a ticket (upstream's people commands).
+            ctx.effect(() => webServer.register({
+                kind: 'exact',
+                path: '/__dsh_a2a/superagent',
+                handler: controlRoute((req, res) => {
+                    const send = (status, value) => { const payload = JSON.stringify(value); res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }); res.end(payload); };
+                    if (req.method === 'GET') {
+                        send(200, superagentHost.state());
+                        return;
+                    }
+                    readJsonBody(req, res, (body) => {
+                        const fields = body;
+                        try {
+                            if (fields.action === 'settings') {
+                                send(200, superagentHost.saveSettings(fields.settings, id => joinedSessions.has(id) && archivedSessionFilter()?.(id) !== true, sessionPresetOf));
+                            }
+                            else if (fields.action === 'request') {
+                                send(200, superagentHost.request(typeof fields.text === 'string' ? fields.text : '', typeof fields.thread === 'string' ? fields.thread : undefined, fields.via === 'cli' ? 'cli' : undefined));
+                            }
+                            else if (fields.action === 'answer') {
+                                send(200, superagentHost.answer(typeof fields.ticket_id === 'string' ? fields.ticket_id : '', typeof fields.text === 'string' ? fields.text : ''));
+                            }
+                            else if (fields.action === 'add-remote-member' || fields.action === 'remove-remote-member') {
+                                // Design v5: a remote member is a remote slot of the bound canvas team — added on the canvas, which pins its key.
+                                send(200, { ok: false, error: 'the team is a canvas team: add or remove a remote member on the canvas (/__dsh_a2a/canvas add-member / remove-member)' });
+                            }
+                            else if (fields.action === 'serve-team') {
+                                // Design v5 (D4): a team is served by its canvas id, which names its owner by key fingerprint.
+                                send(200, { ok: false, error: "serve a team by its canvas id: POST { action: 'serve', team: '<zone>/canvas/<name>@<fp8>', members: [<local session ids>] } (team: null leaves)" });
+                            }
+                            else if (fields.action === 'serve') {
+                                // Design v5 (D4): serve another host's team — the canvas team `<zone>/canvas/<name>@<fp8>`. The fingerprint picks
+                                // the linked peer whose signed card key it names and which advertises that canvas; that key is pinned, so only it
+                                // may assign these sessions work. null leaves. The member host's owner consents here; the team host cannot
+                                // take another host's sessions on its own (U17).
+                                if (fields.team === null) {
+                                    send(200, superagentHost.serveTeam(undefined, [], () => false));
+                                    return;
+                                }
+                                const team = typeof fields.team === 'string' ? fields.team.trim() : '';
+                                const members = Array.isArray(fields.members) ? fields.members.filter((m) => typeof m === 'string') : [];
+                                void (async () => {
+                                    const split = splitCanvasOwner(team);
+                                    if (split.owner === undefined || !/^[^/\s]+\/canvas\/[^/\s]+$/.test(split.team)) {
+                                        send(200, { ok: false, error: 'team must be a canvas id with its owner: <zone>/canvas/<name>@<fp8>' });
+                                        return;
+                                    }
+                                    if (split.owner === ownCanvasFingerprint) {
+                                        send(200, { ok: false, error: "that canvas is this host's own: its sessions join it as members on the canvas" });
+                                        return;
+                                    }
+                                    let found;
+                                    for (const url of new Set([...peerStore.list(), ...cardCache.keys()])) {
+                                        const card = await fetchPeerCard(url).catch(() => undefined);
+                                        if (card === undefined || !verifyCard(card, Date.now()).ok || typeof card.publicKey !== 'string' || canvasOwnerFingerprint(card.publicKey) !== split.owner)
+                                            continue;
+                                        if (!(card.canvasOrg ?? []).some(entry => entry.team === split.team && entry.team === card.team + '/canvas/' + entry.name))
+                                            continue;
+                                        found = { url, card };
+                                        break;
+                                    }
+                                    if (found === undefined) {
+                                        send(200, { ok: false, error: `no linked peer's signed card is the owner of ${team} (key fingerprint ${split.owner}) and advertises it` });
+                                        return;
+                                    }
+                                    // The link judgement reads the cached card: cache the verified one first, as the canvas member proof does.
+                                    cardCache.set(found.url, { at: Date.now(), card: found.card });
+                                    if (peerAdmissionLinkState(found.url).link !== 'linked') {
+                                        send(200, { ok: false, error: 'the team host must be a linked peer' });
+                                        return;
+                                    }
+                                    send(200, superagentHost.serveTeam({ url: new URL(found.url).origin, key: found.card.publicKey, canvas: team }, members, id => joinedSessions.has(id) && archivedSessionFilter()?.(id) !== true, sessionPresetOf));
+                                })().catch(error => send(200, { ok: false, error: String(error) }));
+                            }
+                            else if (fields.action === 'reevaluate') {
+                                // Design superagent-reevaluate-note D1: the owner asks for a fresh judgement of a stored message.
+                                send(200, superagentHost.reevaluate(typeof fields.trigger_id === 'string' ? fields.trigger_id : ''));
+                            }
+                            else if (fields.action === 'stop' || fields.action === 'retry') {
+                                const ticketId = typeof fields.ticket_id === 'string' ? fields.ticket_id : '';
+                                const ticket = fields.action === 'stop'
+                                    ? superagentHost.engine.stopTicket(ticketId, typeof fields.reason === 'string' ? fields.reason : undefined)
+                                    : superagentHost.engine.retryTicket(ticketId);
+                                superagentHost.pass();
+                                send(200, { ok: true, ticket });
+                            }
+                            else
+                                send(200, { ok: false, error: 'action must be settings, request, answer, serve, stop, retry or reevaluate' });
+                        }
+                        catch (error) {
+                            send(200, { ok: false, error: error instanceof Error ? error.message : String(error) });
+                        }
+                    }, 64_000);
+                }),
+            }), 'a2a: superagent control route');
+            // PR-C2: the two host-to-host faces. Each takes a signed, body-bound OriginClaim and judges the signer's card key against
+            // the key the owner pinned: the team host's key on a member host, the member host's key on the team host.
+            const signedFace = (path, judge, label) => {
+                ctx.effect(() => webServer.register({
+                    kind: 'exact',
+                    path,
+                    handler: (req, res) => {
+                        const send = (value) => { const payload = JSON.stringify(value); res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }); res.end(payload); };
+                        if (req.method !== 'POST') {
+                            send({ ok: false, error: 'POST required' });
+                            return;
+                        }
+                        const chunks = [];
+                        let size = 0;
+                        req.on('data', (chunk) => { size += chunk.length; if (size <= 64 * 1024)
+                            chunks.push(chunk); });
+                        req.on('end', () => {
+                            void (async () => {
+                                if (size > 64 * 1024) {
+                                    send({ ok: false, error: 'payload too large' });
+                                    return;
+                                }
+                                const rawBody = Buffer.concat(chunks);
+                                let body;
+                                try {
+                                    body = JSON.parse(rawBody.toString('utf8'));
+                                }
+                                catch {
+                                    send({ ok: false, error: 'not JSON' });
+                                    return;
+                                }
+                                const claim = await verifyOriginClaim(req, { rawBody });
+                                if (!claim.ok || !claim.bound || claim.bodyBound !== true || typeof claim.card.publicKey !== 'string') {
+                                    recordActivity('in', path, String(req.headers['x-a2a-caller'] ?? 'unknown'), false);
+                                    superagentHost.noteRefusal('superagent-untrusted-origin', { caller: String(req.headers['x-a2a-caller'] ?? 'unknown'), target: path });
+                                    send({ ok: false, code: 'untrusted-origin', error: `a signed, body-bound OriginClaim is required (${claim.ok ? 'unbound' : claim.reason})` });
+                                    return;
+                                }
+                                const out = judge(body, { caller: claim.caller, key: claim.card.publicKey });
+                                recordActivity('in', path, claim.caller, out.ok === true);
+                                // A signer that is not the pinned key (an impostor sharing a handle) is refused by identity; a malformed body is not counted.
+                                if (out.ok !== true && ['not-signer', 'not-team', 'not-member'].includes(String(out.code)))
+                                    superagentHost.noteRefusal(`superagent-${String(out.code)}`, { caller: claim.caller, target: path });
+                                send(out);
+                            })().catch(error => send({ ok: false, error: String(error) }));
+                        });
+                    },
+                }), label);
+            };
+            signedFace('/a2a/superagent-member', (body, claim) => superagentHost.assignedWork(body.op, body.member, claim.key, body.text), 'a2a: superagent member face');
+            signedFace('/a2a/superagent-team', (body, claim) => typeof body.member === 'string' && claimCovers(body.member, claim.caller)
+                ? superagentHost.remoteEvent(body.op, body.member, claim.key, body.report)
+                : { ok: false, code: 'not-signer', error: 'the signer does not speak for that member' }, 'a2a: superagent team face');
+        });
     whenWebServerSettled((webServer) => {
         // Task-ledger control: explicit caller-side abandonment of one owed
         // async task — the orchestrator's give-up path (work-order P1a).
@@ -2873,6 +3306,7 @@ export function apply(ctx, config) {
                     const taskId = typeof fields.task_id === 'string' ? fields.task_id : '';
                     const reason = typeof fields.reason === 'string' ? fields.reason : undefined;
                     const result = taskLedger.abandon(taskId, reason);
+                    pruneReceiptWaiters();
                     const payload = JSON.stringify(result);
                     res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
                     res.end(payload);
@@ -3075,6 +3509,9 @@ export function apply(ctx, config) {
     // The cache is still empty here, so the observer skips cache-resting rows
     // on 'boot' (#138 R1); the first lazy read rechecks them.
     ctx.effect(() => canvasStore.onChange(() => observeAuthorization('canvas')), 'a2a: S6 canvas observer');
+    // Design v5: the team's pool is its canvas team's; a canvas change is a pool change.
+    if (superagentHost !== undefined)
+        ctx.effect(() => canvasStore.onChange(() => { superagentHost.poolChanged(); }), 'a2a: superagent team canvas');
     ctx.effect(() => joinedSessions.onChange(() => observeAuthorization('joined')), 'a2a: S6 joined observer');
     ctx.effect(() => teamMemberships.onChange(() => observeAuthorization('roster')), 'a2a: S6 roster observer');
     observeAuthorization('boot');
@@ -3449,19 +3886,6 @@ export function apply(ctx, config) {
                     origin: localOrigin,
                 };
             }),
-            // Native-teams registry rows (opt-in bridge): local teams this node
-            // can dispatch inbound. They list only when the operator opted in —
-            // registry presence alone is never network exposure.
-            ...(config.nativeTeamsInbound === true
-                ? (teamsRegistry()?.listTeams() ?? []).map(entry => ({
-                    team: entry.name,
-                    session,
-                    name: entry.name,
-                    description: entry.description,
-                    local: true,
-                    origin: localOrigin,
-                }))
-                : []),
         ];
         const fetch = memoizedCardFetch();
         // Collect per peer in store order (concurrent fetches, ordered merge):
@@ -3541,19 +3965,19 @@ export function apply(ctx, config) {
         if (!result.ok)
             return;
         birth = { ...birth, ...(typeof result.consumed === 'boolean' ? { consumed: result.consumed } : {}) };
-        // Native-teams bridge rounds emit no A2A receipt in this slice: booking
-        // them as receipt-owed would fill the owed book with rows no receipt can
+        // A peer still running the retired native-teams bridge (0.7.0 and older) marks those rounds: they emit no A2A
+        // receipt, so booking them as receipt-owed would fill the owed book with rows no receipt can
         // ever settle (evicting genuinely receivable peer rows past TASK_CAP).
         if (result.bridge !== undefined)
             return;
-        if (result.task_status !== 'TASK_STATE_DELIVERED' && result.receiverBookkeeping !== 'failed')
+        if (result.task_status !== 'TASK_STATE_DELIVERED' && result.receiverBookkeeping !== 'failed' && !(result.task_status === 'TASK_STATE_COMPLETED' && result.replyFinal !== true && result.receipt !== 'mailbox'))
             return;
         // Fix ② (ghost-debt stop): a delivered async dispatch with no routable
         // callback address can never be settled — register it receiptless
         // (visible, non-debt; reconcile via context_id) instead of stranding a
         // row whose only exit was the dead-letter sweep (57 dead letters, half
         // this shape).
-        if (callbackAddress === undefined) {
+        if (callbackAddress === undefined || result.receipt === 'none') {
             taskLedger.trackReceiptless(taskId, team, peer, result.context_id === '' ? undefined : result.context_id, brief, sender, birth);
             return;
         }
@@ -3701,6 +4125,13 @@ export function apply(ctx, config) {
         const foreignOwner = ownerQualified.owner !== undefined && ownerQualified.owner !== ownCanvasFingerprint ? ownerQualified.owner : undefined;
         if (ownerQualified.owner !== undefined)
             args = { ...args, team: ownerQualified.team };
+        {
+            const refusal = superagentRouterRefusal(agent === undefined ? undefined : String(agent.id), String(args.team ?? '').trim());
+            if (refusal !== undefined) {
+                recordActivity('out', String(args.team ?? ''), agent !== undefined ? sessionTeamOf(agent) : 'local', false);
+                return { ok: false, error: refusal, code: -32000 };
+            }
+        }
         // A receipt may use only its own frozen return lane; local answer state is not delivery proof.
         const answer = parseReceipt(args.message);
         const receiptRow = answer === null ? undefined : taskLedger.find(answer.taskId);
@@ -3739,7 +4170,9 @@ export function apply(ctx, config) {
                 initiator = ctx.get('agents')?.requireInitiator() === agent;
             }
             catch { /* no initiator in this fiber */ }
-            if (!initiator) {
+            // Design v5 (Q1): the bound team canvas takes requests from any session of this host; the team's Policy decides
+            // whether it works on them, so team scope does not gate the route.
+            if (!initiator && teamMailboxOf(String(args.team ?? '')) === undefined) {
                 const callerHandle = `${config.team}/${id8(scopeCaller)}`;
                 scopedCanvasCaller = { id: scopeCaller, handle: callerHandle };
                 const scope = await outboundScope(senderScopeRecords, scopeCaller, callerHandle, String(args.team ?? '').trim());
@@ -3802,6 +4235,8 @@ export function apply(ctx, config) {
                 // gh#198: host-built delivery notes, or a reply from a clean local session (resolved as routeIntoAgent does), are this host's alone.
                 return ((outcome.bridge === undefined && (outcome.task_status === 'TASK_STATE_DELIVERED' || outcome.task_status === 'TASK_STATE_ABORTED_WAIT' || (t => t !== undefined && nodeTaint.of(String(t.id)) === '')(resolveAgentForTeam(args.team) ?? canvasLiveAgent(parseCanvasTeamName(args.team))))) ? localRoute(outcome) : outcome);
             }
+            if (outcome.acceptance === 'unknown')
+                return localRoute(outcome);
             failures.push(`local: ${outcome.error}`);
         }
         // Failover seam for canvas teams: after the local tiers miss, the
@@ -3848,6 +4283,8 @@ export function apply(ctx, config) {
                 peerAsync = card !== undefined && caps?.async === true;
             }
             const result = await dispatchPeerCandidate(candidate, target, args.message, args.context_id, signal, callerSession, peerAsync, taskId, callbackAddress);
+            if (!result.ok && result.acceptance === 'unknown')
+                return result;
             if (result.ok || signal.aborted) {
                 // A receipt the creditor refused (its enforce verdict) pays nothing here either (review of PR #149 P2-2).
                 if (result.ok && routedReceipt) {
@@ -3897,11 +4334,18 @@ export function apply(ctx, config) {
         // the cheapest path. The initiator face (bare node team) and
         // foreign-zone labels are NOT gated here (F1b host-face rules, R-C
         // pending) — only the joined face closes.
-        const joinedRefusal = joinedFaceAdmissionRefusal(callerSession, team);
+        // Design v5 (D2, Q1): a route to the bound team canvas is a route to the team's mailbox, admitted as one.
+        const mailTeam = teamMailboxOf(team) ?? team;
+        const joinedRefusal = joinedFaceAdmissionRefusal(callerSession, mailTeam);
         if (joinedRefusal !== undefined) {
             recordActivity('out', team, callerSession ?? 'local', false);
             return { ok: false, error: joinedRefusal, code: -32000 };
         }
+        const routerRefusal = superagentRouterRefusal(undefined, team) ?? teamAddressRefusal(team, message);
+        if (routerRefusal !== undefined) {
+            recordActivity('out', team, callerSession ?? 'local', false);
+            return { ok: false, error: routerRefusal, code: -32000 };
+        }
         // #114 S5: the same header-safe id rule the wire face enforces.
         const idRefusal = taskIdFromCaller === undefined ? undefined : taskIdRefusal(taskIdFromCaller);
         if (idRefusal !== undefined) {
@@ -3909,7 +4353,9 @@ export function apply(ctx, config) {
             return { ok: false, error: idRefusal, code: -32000 };
         }
         // gh#224: a full target queue refuses a same-host delivery as the wire face does (receipts, CLI mailboxes pass).
-        const queueRefusal = queueFullRefusal(taskLedger.list(), team, message, config.targetQueueCap, cliDeposits.get(team) !== undefined, ownTask);
+        // p1-mailbox-owes (S33): a deposit that declares it owes receipts is under the cap like a session.
+        // superagent v4: a request to the team's A2A address is a Trigger; the engine's worker slots govern it, not this cap.
+        const queueRefusal = queueFullRefusal(taskLedger.list(), team, message, config.targetQueueCap, (cliDeposits.get(mailTeam) !== undefined && !cliDeposits.owes(mailTeam)) || superagentHost?.a2aAddress === mailTeam, ownTask);
         if (queueRefusal !== undefined) {
             recordActivity('out', team, callerSession ?? 'local', false);
             return { ok: false, error: queueRefusal, code: WIRE_ERROR_QUEUE_FULL, next: QUEUE_FULL_NEXT };
@@ -3934,22 +4380,36 @@ export function apply(ctx, config) {
         // polls while alive; receipts and messages never wake anything).
         // The settler of any receipt on this path: this host's own caller (in-process).
         const localSettler = { caller: callerSession ?? '', proof: 'in-process', ingress: 'local' };
-        const cliRow = cliDeposits.get(team);
+        const cliRow = cliDeposits.get(mailTeam);
         if (cliRow !== undefined) {
             // #114 S4 (design §4.5): a receipt dropped into a local CLI mailbox is
             // exactly the settlement a CLI-originated task waits for — settle it,
             // as the wire face settles before ITS mailbox split.
             settleAndAnnounce(message, localSettler);
-            cliDeposits.mail(team, callerSession ?? 'unknown', message);
+            const answered = parseReceipt(message);
+            const disposition = answered?.envelope?.disposition;
+            // p1-mail-admission: the same-host admission this delivery passed (a joined face's rule, else local-exempt).
+            const localAdmission = localCandidateAdmission(admissionRecords, callerSession, mailTeam);
+            const evicted = cliDeposits.mail(mailTeam, callerSession ?? 'unknown', message, undefined, { taskId: taskIdFromCaller, contextId, proof: 'in-process', ...(answered !== null ? { receiptFor: answered.taskId } : {}), ...(disposition !== undefined ? { disposition } : {}),
+                ...(localAdmission.ok ? { admission: localAdmission.rule } : {}) });
+            // p1-mailbox-owes (D-5): a row the cap pushed out takes its owed inbound row with it.
+            for (const gone of evicted)
+                if (gone.task_id !== undefined)
+                    taskLedger.evictInbound(gone.task_id, taskLedger.find(gone.task_id)?.team ?? mailTeam);
             recordActivity('in', team, callerSession ?? 'peer', true);
-            logger.info(`a2a: cli mailbox delivery for ${team} (from ${callerSession ?? 'unknown'})`);
-            return { ok: true, team, reply: `delivered to the mailbox of ${team} — the CLI polls while online`, task_id: taskIdFromCaller ?? '', context_id: contextId ?? '', task_status: 'TASK_STATE_COMPLETED' };
+            logger.info(`a2a: cli mailbox delivery for ${mailTeam} (from ${callerSession ?? 'unknown'}${mailTeam !== team ? `, addressed to ${team}` : ''})`);
+            // Design v5 (R5): the team works asynchronously — a sync route to it answers at once, delivered.
+            if (mailTeam !== team && answered === null && taskIdFromCaller !== undefined)
+                return { ok: true, team, reply: `delivered to the superagent team ${team} — it works asynchronously; its result arrives as this task's receipt`, task_id: taskIdFromCaller, context_id: contextId ?? '', task_status: 'TASK_STATE_DELIVERED', receipt: 'mailbox' };
+            if (answered === null && taskIdFromCaller !== undefined && cliDeposits.owes(team)) {
+                // p1-mailbox-owes (S33, D-2): delivered, not final. On one host the caller and the target share this ledger: the
+                // caller's own owed row (peer 'local', booked by trackOwedTask) is the one the per-target cap counts, as for a
+                // same-host session, so no separate inbound row is kept.
+                return { ok: true, team, reply: `delivered to the mailbox of ${team} — it owes a receipt`, task_id: taskIdFromCaller, context_id: contextId ?? '', task_status: 'TASK_STATE_DELIVERED', receipt: 'mailbox' };
+            }
+            // S29 / #404: a plain mailbox is final for the caller, as on the wire face (receipt 'mailbox'), so no debt is booked.
+            return { ok: true, team, reply: `delivered to the mailbox of ${team} — the CLI polls while online`, task_id: taskIdFromCaller ?? '', context_id: contextId ?? '', task_status: 'TASK_STATE_COMPLETED', receipt: 'mailbox' };
         }
-        // The native-teams claim probe is an await: pay it only when the four
-        // cheap synchronous locality checks missed (a registry team is a local
-        // candidate even though no session node backs it).
-        if (!teamIsLocal && team !== config.team)
-            teamIsLocal = await nativeTeamsClaims(team);
         if (!teamIsLocal || webServer === undefined)
             return undefined;
         // A receipt relayed between same-host sessions (the answering session
@@ -3971,42 +4431,7 @@ export function apply(ctx, config) {
                 ? Promise.resolve(agent)
                 : wake?.kind === 'flight' ? wake.flight : undefined;
             if (woken === undefined) {
-                // Bridge BEFORE the bare-team fallback — claim beats the initiator
-                // redirect, the same rule routeIntoAgent follows (a bare team name
-                // claimed by the registry must not fork its destination by wait
-                // semantics). Prepare-first: claim, seam, and parent initiator are
-                // everything that can fail fast, so a phantom delivery never answers
-                // success. The fire is truly detached (no caller signal — the turn
-                // ending must not silently retract an already-announced delivery);
-                // rounds emit no receipt in this slice (the `bridge` marker keeps
-                // the caller's ledger honest).
-                const prepared = await nativeTeamsPrepare(team);
-                if (prepared.ok) {
-                    endRoute(flight);
-                    recordActivity('out', team, 'local', true);
-                    void nativeTeamsRound(prepared, team, callerSession ?? session, message, taskId, '未验证（in-process）', undefined, hostDirectHeader)
-                        .then(outcome => {
-                        if (!outcome.ok) {
-                            recordActivity('out', team, 'local', false);
-                            logger.warn(`a2a: detached native-teams round for "${team}" failed: ${outcome.error}`);
-                        }
-                    });
-                    return {
-                        ok: true,
-                        team,
-                        reply: `Delivered to ${team} (async native-teams round dispatched). The round settles through the team's own routing chain; it routes no A2A receipt in this slice — reconcile via context_id follow-ups.`,
-                        task_id: taskId,
-                        context_id: contextId ?? `ctx-${Math.random().toString(16).slice(2, 10)}`,
-                        task_status: 'TASK_STATE_DELIVERED',
-                        bridge: 'native-teams',
-                    };
-                }
-                if (prepared.reason === 'error') {
-                    endRoute(flight);
-                    recordActivity('out', team, 'local', false);
-                    return { ok: false, error: prepared.error, code: -32000 };
-                }
-                // Claim declined: the bare process team still steers the live initiator.
+                // The bare process team still steers the live initiator.
                 const live = team === config.team ? liveAgent() : undefined;
                 if (live !== undefined && callerIsAgent(live, callerSession ?? session)) {
                     // Self-route refusal (same rule as the sync faces): the initiator
@@ -4024,6 +4449,12 @@ export function apply(ctx, config) {
             }
             try {
                 const target = await woken;
+                // superagent v4: whatever address resolved to it (a canvas team, the node team), the router takes no A2A work.
+                if (superagentHost?.roleOf(String(target.id)) !== undefined) {
+                    endRoute(flight);
+                    recordActivity('out', team, callerSession ?? 'local', false);
+                    return { ok: false, error: superagentRouterRefusal(undefined, String(target.id)) ?? 'superagent team sessions take no A2A work', code: -32000 };
+                }
                 // N1 (review seat 7e4cf94a): dashed composite labels are NOT routable;
                 // accept only <zone>/<short-id> shapes so envelopes stop bouncing -32004.
                 // An explicit callback address (P2) wins over the caller-label
@@ -4035,8 +4466,9 @@ export function apply(ctx, config) {
                 const receiptHint = callerTeam === undefined ? '' : `\n\n(When done, route your outcome back with one call — a2a_route { team: "${callerTeam}", message: "[A2A receipt] task ${taskId} <one-line outcome>" }.)`;
                 // #114 S5: the consumption search starts at the pre-steer log length.
                 const steerFloor = sessionEventsOf(target).length;
-                followupRelay(target, `[A2A direct] (task ${taskId}) 未验证（in-process） ${sanitizeFromClause(callerSession ?? session)} (routed to ${team}) sent:\n\n${message}${receiptHint}`, callerTeam, originAgentId, taskId, undefined, parseReceipt(message) === null);
-                armReceiptAutosend(target, taskId, callerTeam, message, steerFloor);
+                const acceptance = followupRelay(target, `[A2A direct] (task ${taskId}) 未验证（in-process） ${sanitizeFromClause(callerSession ?? session)} (routed to ${team}) sent:\n\n${message}${receiptHint}`, callerTeam, originAgentId, taskId, undefined, parseReceipt(message) === null);
+                if (acceptance !== 'inserted')
+                    armReceiptAutosend(target, taskId, callerTeam, message, steerFloor);
                 // #139: the caller's outbound row is born with this admission and the member that received it.
                 if (taskIdFromCaller !== undefined)
                     localBirths.set(taskIdFromCaller, localBirthOf(team, callerSession, callerTeam, sessionTeamOf(target), String(target.id)));
@@ -4045,76 +4477,22 @@ export function apply(ctx, config) {
                 return {
                     ok: true,
                     team,
-                    reply: `Delivered to ${team} (async). The target routes a receipt — a message starting "[A2A receipt] task ${taskId} <outcome summary>" — back to your team when done; watch a2a_status activity or follow up with the context id.${routable ? '' : unroutableCallerNote(String(callerSession ?? session))}`,
+                    ...(acceptance === 'inserted' ? { acceptance, consumed: false } : {}),
+                    reply: acceptance === 'inserted' ? ACCEPTANCE_INSERTED_NOTE : `Delivered to ${team} (async). The target routes a receipt — a message starting "[A2A receipt] task ${taskId} <outcome summary>" — back to your team when done; watch a2a_status activity or follow up with the context id.${routable ? '' : unroutableCallerNote(String(callerSession ?? session))}`,
                     task_id: taskId,
                     context_id: contextId ?? `ctx-${Math.random().toString(16).slice(2, 10)}`,
                     task_status: 'TASK_STATE_DELIVERED',
-                    consumed: taskLedger.deliveryFor(taskId)?.state === 'claimed',
+                    consumed: acceptance === 'inserted' ? false : taskLedger.deliveryFor(taskId)?.state === 'claimed',
                 };
             }
             catch (error) {
                 endRoute(flight);
                 recordActivity('out', team, 'local', false);
+                if (error instanceof FollowupAcceptanceUnknown)
+                    return { ok: false, error: ACCEPTANCE_UNKNOWN_NOTE, acceptance: 'unknown', task_id: taskId, code: -32000 };
                 return { ok: false, error: `waking or steering the session for team "${team}" failed: ${String(error)}`, code: -32000 };
             }
         }
-        if (!asyncMode) {
-            // Bridge only on a steer-path miss, matching the documented chain
-            // (session node → canvas → cold wake → native-teams claim → bare): a
-            // registry claim must never shadow a live local session team. The
-            // caller's abort cancels the round through its own signal; the 180s
-            // deadline restores the bound the steer machinery observes.
-            // Issue #41: same initiator exemption on the sync path — the canvas
-            // live/cold tiers skip the dispatching session before steerable is
-            // decided, so a self-member falls through to remote members.
-            const steerable = resolveAgentForTeam(team) !== undefined
-                || canvasLiveAgent(canvasName, callerNodeId) !== undefined
-                || joinedSessions.list().some(id => `${config.team}/${id8(id)}` === team)
-                || wakeColdTeam(team, callerNodeId).kind === 'flight';
-            if (!steerable && team !== config.team) {
-                const prepared = await nativeTeamsPrepare(team);
-                if (prepared.ok) {
-                    const outcome = await nativeTeamsRound(prepared, team, callerSession ?? session, message, taskId, '未验证（in-process）', signal, hostDirectHeader);
-                    endRoute(flight);
-                    if (!outcome.ok) {
-                        // The aborted-wait shape is earned only by an actual round
-                        // cancellation (the caller's abort reached the seam). A
-                        // pre-dispatch abort means the message never left the node, and
-                        // a failed round means it never answered — both answer the
-                        // honest error instead of claiming a delivery.
-                        if (outcome.aborted === true) {
-                            recordActivity('out', team, 'local', true);
-                            return {
-                                ok: true,
-                                team,
-                                reply: `The message was delivered to ${team} (native-teams round), but the wait was aborted (the round was cancelled with it).`,
-                                task_id: taskId,
-                                context_id: contextId ?? `ctx-${Math.random().toString(16).slice(2, 10)}`,
-                                task_status: 'TASK_STATE_ABORTED_WAIT',
-                                bridge: 'native-teams',
-                            };
-                        }
-                        recordActivity('out', team, 'local', false);
-                        return { ok: false, error: outcome.error, code: -32000 };
-                    }
-                    recordActivity('out', team, 'local', true);
-                    return {
-                        ok: true,
-                        team,
-                        reply: outcome.reply,
-                        task_id: taskId,
-                        context_id: contextId ?? `ctx-${Math.random().toString(16).slice(2, 10)}`,
-                        task_status: outcome.settled ? 'TASK_STATE_COMPLETED' : 'TASK_STATE_DELIVERED',
-                        ...(outcome.settled ? {} : { bridge: 'native-teams' }),
-                    };
-                }
-                if (prepared.reason === 'error') {
-                    endRoute(flight);
-                    recordActivity('out', team, 'local', false);
-                    return { ok: false, error: prepared.error, code: -32000 };
-                }
-            }
-        }
         const wait = routeIntoAgent(team, message, callerSession ?? session, taskId, undefined, undefined, originAgentId);
         const aborted = new Promise((_, reject) => {
             signal.addEventListener('abort', () => { reject(new Error('aborted')); }, { once: true });
@@ -4167,14 +4545,16 @@ export function apply(ctx, config) {
             return {
                 ok: true,
                 team,
-                reply: outcome.reply,
+                reply: outcome.placeholder === true ? '已送达、未得到最终答复，请按 task id 对账。 ' + outcome.reply : outcome.reply,
                 task_id: taskId,
                 context_id: contextId ?? `ctx-${Math.random().toString(16).slice(2, 10)}`,
-                task_status: outcome.status ?? 'TASK_STATE_COMPLETED',
-                ...(outcome.bridge !== undefined ? { bridge: outcome.bridge } : {}),
+                task_status: outcome.placeholder === true || outcome.ownTurn !== true && outcome.status === undefined ? 'TASK_STATE_DELIVERED' : outcome.status ?? 'TASK_STATE_COMPLETED',
+                ...(outcome.acceptance === 'inserted' ? { acceptance: 'inserted', consumed: false } : {}),
+                ...(outcome.ownTurn === true && outcome.placeholder !== true ? { replyFinal: true } : {}),
+                ...(outcome.placeholder === true || outcome.ownTurn !== true ? { receipt: 'none' } : {}),
             };
         }
-        return { ok: false, error: outcome.error, code: -32000 };
+        return { ok: false, error: outcome.error, code: -32000, ...(outcome.acceptance === 'unknown' ? { acceptance: 'unknown', task_id: taskId } : {}) };
     }
     /**
      * The route dispatcher's peer half: one candidate dial with the in-flight
@@ -4231,8 +4611,11 @@ export function apply(ctx, config) {
             if (home === undefined)
                 throw new Error(`CLI receipt home is not pinned for ${team}`);
             const delivered = await dispatchPeerCandidate(home, team, message, contextId, signal, peerCaller ?? callerSession, asyncMode, taskId);
-            if (!delivered.ok)
+            if (!delivered.ok) {
+                if (delivered.acceptance === 'unknown')
+                    throw new FollowupAcceptanceUnknown();
                 throw receiptFailure(delivered);
+            }
             return delivered;
         }
         const local = await dispatchLocalCandidate(team, message, callerSession, contextId, signal, asyncMode, taskId);
@@ -4240,8 +4623,11 @@ export function apply(ctx, config) {
         if (taskId !== undefined)
             localBirths.delete(taskId);
         if (local !== undefined) {
-            if (!local.ok)
+            if (!local.ok) {
+                if (local.acceptance === 'unknown')
+                    throw new FollowupAcceptanceUnknown();
                 throw receiptFailure(local);
+            }
             return local;
         }
         if (cliReceipt)
@@ -4257,6 +4643,8 @@ export function apply(ctx, config) {
             const result = await dispatchPeerCandidate(candidate, team, message, contextId, signal, peerCaller ?? callerSession, asyncMode, taskId);
             if (result.ok)
                 return result;
+            if (result.acceptance === 'unknown')
+                throw new FollowupAcceptanceUnknown();
             lastError = result.error;
             const failure = receiptFailure(result);
             if (receiptError === undefined || failure.transient)
@@ -4362,200 +4750,37 @@ export function apply(ctx, config) {
         }
         return candidates;
     }
-    // ── Outbound transport face: the `nativeTeamsA2a` bridge ─────────────
-    //
-    // Contract: @nelsonlongxiang/dsh-native-teams/src/a2a-face.ts (0.14.0,
-    // structural mirror in src/teams-bridge.ts). This plugin mounts the
-    // implementation under the face's frozen service key — protocol
-    // primitives live on the protocol face (three-party consensus), and
-    // native-teams probes it presence-guarded (unmounted ⇒ local-only
-    // routing, never a crash). The face ships only what this plugin already
-    // does for a2a_route: resolve via the ONE directory walk (same matcher
-    // submit uses — no drift-prone double implementation), submit via the
-    // direct-route dispatcher (per-candidate async gate, failover included),
-    // cancel via the cooperative stop-notice. It exposes nothing new — only
-    // teams the tracked peer network already publishes resolve here.
-    const bridgeFace = {
-        resolve: async (handle) => {
-            const failures = [];
-            const candidates = await directoryPeerCandidates(memoizedCardFetch(), handle, failures);
-            if (candidates.length === 0)
-                return undefined;
-            return { kind: 'node', hops: 1, url: candidates[0] };
-        },
-        submit: async (request, signal) => {
-            const abort = signal ?? new AbortController().signal;
-            const failures = [];
-            const fetch = memoizedCardFetch();
-            const candidates = await directoryPeerCandidates(fetch, request.handle, failures);
-            if (candidates.length === 0) {
-                throw new Error(`team "${request.handle}" is not published by any tracked peer${failures.length === 0 ? '' : ` (unresolved delegations: ${failures.join('; ')})`}`);
-            }
-            // The caller-born task id (B3): the orchestrator's dedup key IS the
-            // wire task id, so the peer's echo correlates with the caller's ledger.
-            const taskId = request.idempotencyKey !== undefined && request.idempotencyKey !== ''
-                ? request.idempotencyKey
-                : `direct-${Math.random().toString(16).slice(2, 10)}`;
-            // P2 receipt-callback: the receipt routes back to the submitting
-            // session's own node team, but ONLY when that session is a joined
-            // node. Without a joined parent there is no routable address that
-            // means "this session" on the peer — omitting the callback keeps the
-            // P1 behavior (the caller label cannot resolve on the peer, so the
-            // receipt is lost honestly); falling back to `config.team` would be
-            // actively harmful: a same-named peer resolves it LOCAL-first and the
-            // receipt steers the peer's own initiator, never leaving that host.
-            let callbackAddress;
-            if (request.callbackTarget) {
-                const parent = request.callbackTarget.parentSessionId;
-                if (sessionNodes.has(parent) || joinedSessions.has(parent))
-                    callbackAddress = `${config.team}/${id8(parent)}`;
-            }
-            // #114 S3: the submitting session's node team, but only when the
-            // transport names a session this host knows (a node, a join, or a live
-            // root) — an unchecked id would let any submitter mint a seat. Anything
-            // else (absent, unknown, non-string) is attributed to the host label.
-            const parentSession = request.callbackTarget?.parentSessionId;
-            const knownParent = typeof parentSession === 'string' && parentSession !== ''
-                && (sessionNodes.has(parentSession) || joinedSessions.has(parentSession) || liveRoots.has(parentSession));
-            const sender = { kind: 'bridge', id: knownParent ? `${config.team}/${id8(parentSession)}` : session };
-            for (const candidate of candidates) {
-                // Capability gate per candidate, like a2a_route's loop: a
-                // delivery:async submit never dials a peer whose signed card does
-                // not declare async — failover must not silently degrade into the
-                // minutes-long blocking wait the gate exists to prevent.
-                let peerAsync = false;
-                if (request.delivery === 'async') {
-                    const card = await fetch(candidate);
-                    peerAsync = card?.capabilities?.async === true;
-                }
-                const result = await dispatchPeerCandidate(candidate, splitQualifiedMember(request.handle)?.handle ?? splitCanvasOwner(request.handle).team, request.message, request.contextId, abort, session, request.delivery === 'async' && peerAsync, taskId, callbackAddress);
-                if (!result.ok) {
-                    // Idempotency verdicts (B3) are terminal, not failover: a replay
-                    // says the prior attempt at THIS peer stays authoritative —
-                    // re-dispatching the same dedup key at another peer would execute
-                    // the task twice; a conflict is a caller bug (same key, different
-                    // payload) and must surface as a failure, not a redirect.
-                    if (result.code === WIRE_ERROR_REPLAY_REJECTED) {
-                        // async: acceptance IS the honest outcome — the submission is
-                        // fire-and-forget and the prior attempt settles via the receipt
-                        // contract.
-                        if (request.delivery === 'async') {
-                            return { kind: 'accepted', taskId, acceptedAt: new Date().toISOString(), contextId: request.contextId ?? '' };
-                        }
-                        // sync (W7 recovery table, S1): a sync caller cannot consume an
-                        // acceptance — its verdict contract needs round text, and the
-                        // handle-ack prose would settle a null verdict as a normal node.
-                        // Throw instead, and the frozen -32003 literal MUST ride the
-                        // message: structured codes have no survival channel through the
-                        // downstream submitFailedError wrap (message-only), so the
-                        // graph-loop classifier's probeText match on the code value is
-                        // the only programmatic channel (adjudicated exception to
-                        // "message 禁止下游解析").
-                        throw new Error(`A2A submit for "${request.handle}" replayed at the peer's idempotency ledger (task ${taskId} duplicate within the idempotency window, -32003: the prior attempt stays authoritative — fail-closed; outcome retrieval needs a query face)`);
-                    }
-                    if (result.code === WIRE_ERROR_IDEMPOTENCY_CONFLICT) {
-                        // -32002 literal on the message: same classification channel as the sync replay above.
-                        throw new Error(`A2A submit for "${request.handle}" conflicts at the peer's idempotency ledger (task ${taskId} reused with a different payload, -32002)`);
-                    }
-                    if (abort.aborted)
-                        break;
-                    continue;
-                }
-                trackOwedTask(taskId, splitCanvasOwner(request.handle).team, candidate, result, callbackAddress, briefOf(request.message), sender, await peerBirth(fetch, candidate, undefined));
-                const contextId = request.contextId ?? (result.context_id !== '' ? result.context_id : `ctx-${Math.random().toString(16).slice(2, 10)}`);
-                if (result.task_status === 'TASK_STATE_COMPLETED') {
-                    return { kind: 'completed', text: result.reply, taskId, contextId };
-                }
-                // DELIVERED / ABORTED_WAIT: the message is in and the receipt
-                // contract carries the outcome — the face maps both to the
-                // accepted shape (the submission stays visible in a2a_tasks).
-                return { kind: 'accepted', taskId, acceptedAt: new Date().toISOString(), contextId };
-            }
-            throw new Error(`A2A submit for "${request.handle}" failed on every candidate`);
-        },
-        queryOutcome: async (request, signal) => {
-            const abort = signal ?? new AbortController().signal;
-            if (request.taskId === '')
-                return undefined;
-            const failures = [];
-            const fetch = memoizedCardFetch();
-            const candidates = await directoryPeerCandidates(fetch, request.handle, failures);
-            // No candidate to ask: no increment of information — undefined, never
-            // a synthetic verdict.
-            if (candidates.length === 0)
-                return undefined;
-            let mismatch = false;
-            let answeredUnknown = false;
-            for (const candidate of candidates) {
-                // A caller cancel mid-fan-out ends the probe: answers collected
-                // before the abort must not aggregate into a verdict the caller
-                // already walked away from.
-                if (abort.aborted)
-                    return undefined;
-                // Recompute the fingerprint EXACTLY as the submit pass computed it:
-                // the same shared implementation, and the same per-candidate async
-                // gate (delivery async × that peer's declared capability). Sync
-                // delivery — every graph-loop dispatch — is noWait:false throughout.
-                let peerAsync = false;
-                if (request.delivery === 'async') {
-                    const card = await fetch(candidate);
-                    peerAsync = card?.capabilities?.async === true;
-                }
-                const fingerprint = peerPayloadFingerprint({ caller: session, message: request.message, noWait: request.delivery === 'async' && peerAsync, team: request.handle });
-                const answer = await client.queryOutcome(candidate, request.taskId, fingerprint, abort);
-                if (answer === undefined)
-                    continue; // transport miss — probe the next candidate (read-only fan-out)
-                if (!answer.found) {
-                    if (answer.reason === 'payload-mismatch')
-                        mismatch = true;
-                    else
-                        answeredUnknown = true;
-                    continue;
-                }
-                return answer;
-            }
-            // A mismatch anywhere wins the aggregation: the key exists at a peer
-            // with a different payload — the most diagnostic negative there is.
-            if (mismatch)
-                return { found: false, reason: 'payload-mismatch' };
-            if (answeredUnknown)
-                return { found: false, reason: 'unknown-task' };
-            return undefined;
-        },
-        cancel: async (ref, reason) => {
-            const taskId = ref.taskId;
-            if (!taskId)
-                return false;
-            const row = taskLedger.list().find(entry => entry.taskId === taskId);
-            if (!row)
-                return false;
-            // Caller bookkeeping has priority. Notification compatibility never gates cancellation.
-            const cleared = taskLedger.cancel(taskId, reason).outcome === 'cleared';
-            if (!cleared)
-                return false;
-            try {
-                const notice = cancelNoticeText(taskId, reason);
-                if (row.peer === 'local' || row.direction === 'inbound')
-                    await cancelQueuedTask(taskId, notice, session, row);
-                else {
-                    const card = await cachedCardFetch(row.peer);
-                    const supportsQueuedCancel = card?.capabilities?.queuedTaskCancellation === true;
-                    const result = await client.routeDirect(row.peer, row.team, notice, undefined, undefined, supportsQueuedCancel ? (row.sender?.kind === 'session' ? row.sender.id : row.auth?.caller ?? session) : session, true, undefined, undefined, undefined, supportsQueuedCancel ? taskId : undefined);
-                    if (!result.ok)
-                        throw Error(result.error);
-                }
-            }
-            catch (error) {
-                logger.warn('a2a: cancellation committed; stop notice was best-effort: %s', String(error));
-            }
-            return true;
-        },
-    };
-    ctx.reflect.provide(NATIVE_TEAMS_A2A_FACE_KEY, bridgeFace);
     infoTools.registerStatus();
     infoTools.registerTasks();
     infoTools.registerProbe();
     const pendingFinals = new Map();
+    function removeFinalWaiter(agentId, entry) {
+        const kept = (pendingFinals.get(agentId) ?? []).filter(other => other !== entry);
+        if (kept.length)
+            pendingFinals.set(agentId, kept);
+        else
+            pendingFinals.delete(agentId);
+        entry.timeoutDisposer?.();
+    }
+    function pruneReceiptWaiters() {
+        for (const [id, entries] of pendingFinals) {
+            for (const entry of entries) {
+                if (entry.purpose === 'receipt' && entry.taskId !== undefined && !taskLedger.isPending(entry.taskId))
+                    removeFinalWaiter(id, entry);
+            }
+        }
+    }
+    ctx.effect(() => {
+        // Also cover task eviction/expiry independently of session idle events.
+        const stop = ctx.timer.interval(pruneReceiptWaiters, 1000);
+        return () => {
+            stop();
+            for (const entries of pendingFinals.values())
+                for (const entry of entries)
+                    entry.timeoutDisposer?.();
+            pendingFinals.clear();
+        };
+    }, 'a2a: final waiter lifecycle');
     function answerFinalSafely(entry, text, placeholder) {
         try {
             entry.answer(text, placeholder);
@@ -4581,16 +4806,17 @@ export function apply(ctx, config) {
         }, config.flushTimeoutMs);
     };
     function flushFinals(agentId) {
+        pruneReceiptWaiters();
         const entries = pendingFinals.get(agentId);
         if (entries === undefined || entries.length === 0)
             return;
         const agent = ctx.get('agents')?.get(SessionId(agentId));
         if (agent === undefined) {
-            for (const entry of entries) {
-                entry.timeoutDisposer?.();
-                answerFinalSafely(entry, 'The target DSH session is no longer live.', true);
-            }
-            pendingFinals.delete(agentId);
+            for (const entry of entries)
+                if (entry.purpose === 'http') {
+                    removeFinalWaiter(agentId, entry);
+                    answerFinalSafely(entry, 'The target DSH session is no longer live.', true);
+                }
             return;
         }
         // #114 S5: each waiter is answered from its OWN floor. The old shared
@@ -4628,6 +4854,9 @@ export function apply(ctx, config) {
         if (answered.length === 0)
             return;
         for (const { entry, reply, placeholder } of answered) {
+            // A closed empty/failed reading has no later attributable final: remove it,
+            // invoke the existing placeholder no-op, and dispose its timer. HTTP expiry
+            // itself does not enter this receipt path (receipt uses the original TTL).
             // Remove one callback before invoking (it may synchronously re-enter), never the whole batch.
             const current = pendingFinals.get(agentId) ?? [];
             if (!current.includes(entry))