@nelsonlongxiang/dsh-open-a2a-net 0.6.37 → 0.6.38

package/lib/index.js

@@ -32,13 +32,14 @@ import { CanvasStore, canvasNameReserved, isRemoteMemberRef } from "./canvas-sto
 import { decodeSessionLog, extractTranscript, TRANSCRIPT_MAX_FILE_BYTES } from "./session-transcript.js";
 import { LayoutStore } from "./layout-store.js";
 import { peerLinkDisplay } from "./peer-link-display.js";
+import { canvasOwners, canvasFailure } from "./canvas-discovery.js";
 import { JoinedSessions } from "./joined-store.js";
 import { ExposureStore } from "./exposure-store.js";
 import { loadSeatNames } from "./owner-settings.js";
 import { CLI_HANDLE_RE, CliDepositStore } from "./cli-deposit.js";
 import { cliHomeChoices, decideCliHome } from "./cli-home.js";
 import { outboundScope } from "./outbound-scope.js";
-import { createDirectForward } from "./direct-forward.js";
+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";
@@ -89,7 +90,7 @@ export const Config = s.object({
     settlementAuth: s.union(['off', 'observe', 'enforce']).default('observe'),
     announce: s.boolean().default(false),
     isolated: s.boolean().default(false),
-    forwardDirect: s.boolean().default(false),
+    forwardDirect: s.boolean().default(true),
     agentName: s.string().default('DeepSeek Harness A2A node'),
     peers: s.array(s.string()).default([]),
     delegates: s.array(s.object({ name: s.string(), url: s.string(), publicKey: s.string().default('') })).default([]),
@@ -682,7 +683,13 @@ export function apply(ctx, config) {
     // queryable here, and the correlating `[A2A receipt] task <id>` message
     // resolves it — the caller-side half of the receipt contract, persisted so
     // a restart does not orphan the reconciliation.
-    const taskLedger = new TaskLedger(join(home, 'a2a', 'tasks.json'), { staleTtlMs: config.taskStaleTtlMs });
+    const taskLedger = new TaskLedger(join(home, 'a2a', 'tasks.json'), { staleTtlMs: config.taskStaleTtlMs, warn: message => logger.warn(message) });
+    const enforceBlockers = taskLedger.settlementEnforceBlockers();
+    const enforceRefused = config.settlementAuth === 'enforce' && enforceBlockers.length > 0 ? { reason: 'legacy forwarded canvas debts lack receiver facts', blockers: enforceBlockers } : undefined;
+    if (enforceRefused !== undefined) {
+        logger.error('settlementAuth enforce refused; running observe (#125/#275): %s', JSON.stringify(enforceRefused));
+        config = { ...config, settlementAuth: 'observe' };
+    }
     // Unjoined-node reporting ingress (design: docs/design/unjoined-report-ingress.md):
     // a one-way signal channel for sessions with no network membership — a
     // fallen-off or never-joined session reports "I exist / I have a task"
@@ -727,6 +734,12 @@ export function apply(ctx, config) {
      * the consumer's own discipline — keep seam listeners synchronous.
      * @param message - the inbound or relayed message text.
      */
+    const forwardingBirths = new ForwardBirths();
+    async function waitForForwardBirth(message) {
+        const receipt = parseReceipt(message);
+        if (receipt !== null)
+            await forwardingBirths.wait(receipt.taskId);
+    }
     function settleAndAnnounce(message, settler) {
         const parsedForJudge = parseReceipt(message);
         const judge = settlementJudgeFor(settler, parsedForJudge);
@@ -1660,12 +1673,13 @@ export function apply(ctx, config) {
             // gh#77 B1: the admin faces live in src/faces/admin.ts.
             registerAdminFaces(webServer, {
                 ctx, config, logger, home, session, lanIp, PLUGIN_VERSION, controlRoute, controlTrustedWithoutKey, readJsonBody, peerFetch, peerStore, peerLinkState, originClaimHeaders, refreshRemoteRows, joinedSessions, exposureStore, teamMemberships, cliDeposits, groupStore, canvasStore, 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,
+                indexUrl: import.meta.url, enforceRefused,
                 get cardCache() { return cardCache; },
                 get remoteRowsCache() { return remoteRowsCache; },
                 get legacyInboundCount() { return legacyInboundCount; },
                 get unboundInboundCount() { return unboundInboundCount; },
                 get boundMissInboundCount() { return boundMissInboundCount; },
+                get boundMissRecent() { return boundMissRecent; },
                 get ownCardUrl() { return ownCardUrl; },
                 get ownerSeatNames() { return ownerSeatNames; },
                 set ownerSeatNames(v) { ownerSeatNames = v; },
@@ -2121,15 +2135,15 @@ export function apply(ctx, config) {
      * marker instead of a (false) completion.
      * @param taskId - the correlation key the steered receipt header carries.
      */
-    async function routeIntoAgent(team, message, caller, taskId, proofClause, buildHeader, localFrom) {
+    async function routeIntoAgent(team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered) {
         const agent = resolveAgentForTeam(team) ?? canvasLiveAgent(parseCanvasTeamName(team));
         if (agent !== undefined) {
-            return routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom);
+            return routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered);
         }
         // Wake-on-route: a cold joined team materializes on demand, then steers.
         const wake = wakeColdTeam(team);
         if (wake.kind === 'flight') {
-            return wake.flight.then(agent => routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom), (error) => ({ ok: false, error: `waking the session for team "${team}" failed: ${String(error)}` }));
+            return wake.flight.then(agent => routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered), (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
@@ -2158,7 +2172,7 @@ export function apply(ctx, config) {
             if (live !== undefined) {
                 if (callerIsAgent(live, caller))
                     return { ok: false, error: selfRouteText(team) };
-                return routeIntoAgentFor(live, team, message, caller, taskId, proofClause, buildHeader);
+                return routeIntoAgentFor(live, team, message, caller, taskId, proofClause, buildHeader, undefined, onSteered);
             }
             return { ok: false, error: 'No live DSH agent is available to accept this message.' };
         }
@@ -2173,7 +2187,7 @@ export function apply(ctx, config) {
      * @param caller - caller label for the steered prefix.
      * @returns the agent's final reply, or the explicit failure.
      */
-    function routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom) {
+    function routeIntoAgentFor(agent, team, message, caller, taskId, proofClause, buildHeader, localFrom, onSteered) {
         return new Promise((resolve) => {
             const waiter = registerFinalWaiter(agent, (text, placeholder) => {
                 resolve({ ok: true, reply: text, ...(placeholder === true ? { placeholder: true } : {}) });
@@ -2190,7 +2204,11 @@ export function apply(ctx, config) {
                 : `[A2A direct] ${taskId === undefined ? '' : `(task ${taskId}) `}未验证（in-process） ${sanitizeFromClause(from)} (routed to ${team}) sent:`;
             const text = `${headerLine}\n\n${message}`;
             try {
+                const floor = sessionEventsOf(agent).length;
                 steerRelay(agent, text, caller === '' ? undefined : caller, localFrom);
+                onSteered?.(agent, floor);
+                if (onSteered !== undefined && sessionEventsOf(agent).slice(floor).some(event => event?.type === 'assistant/message'))
+                    queueMicrotask(() => flushFinals(String(agent.id))); // synchronous final may already have emitted idle
             }
             catch (error) {
                 // The waiter was registered above, so the key always holds it; the
@@ -2223,6 +2241,15 @@ export function apply(ctx, config) {
      *  closing originClaimUnboundWindow; boundMissInbound: those of them whose
      *  bound form missed (a peer dials us by a name not in our audiences). */
     let unboundInboundCount = 0, boundMissInboundCount = 0;
+    /** Which verified callers missed, and the origin they dialled: what to add to originClaimAudiences (#64). */
+    const boundMissRecent = [];
+    const noteBoundMiss = (miss) => {
+        boundMissInboundCount += 1;
+        const at = boundMissRecent.findIndex(row => row.caller === miss.caller && row.audience === miss.audience);
+        const row = at >= 0 ? boundMissRecent.splice(at, 1)[0] : { ...miss, count: 0, lastAt: 0 };
+        boundMissRecent.unshift({ ...row, count: row.count + 1, lastAt: Date.now() });
+        boundMissRecent.length = Math.min(boundMissRecent.length, 16);
+    };
     function verifyOriginClaim(req, options) {
         return verifyOriginClaimOf(req, {
             cardCache,
@@ -2230,7 +2257,7 @@ export function apply(ctx, config) {
             audiences: [ownCardUrl, ...config.originClaimAudiences ?? []],
             unboundOpen: config.originClaimUnboundWindow !== false,
             onUnbound: () => { unboundInboundCount += 1; },
-            onBoundMiss: () => { boundMissInboundCount += 1; },
+            onBoundMiss: noteBoundMiss,
             loopbackArrival: (config.originClaimUrl ?? '') === '',
             now: Date.now(),
             ...(options?.cli === true ? { cliDeposit: cliDepositCard } : {}),
@@ -2567,6 +2594,7 @@ export function apply(ctx, config) {
             verifyOriginClaim,
             remoteCliProof,
             forwardDirect: request => forwardDirect(request),
+            diagnoseCanvas: (team, reason, caller) => diagnoseCanvas(team, reason, caller),
             callerLinkedToThisHost, get ownCardUrl() { return ownCardUrl; },
             recordActivity,
             bumpLegacyInbound: () => { legacyInboundCount += 1; },
@@ -2580,7 +2608,7 @@ export function apply(ctx, config) {
             taskLedger,
             refuseIfFlooded,
             refuseIfQueueFull,
-            settleAndAnnounce,
+            settleAndAnnounce, waitForForwardBirth,
             touchWakeDemand: () => { lastWakeDemandAt = Date.now(); },
             session,
             resolveAgentForTeam,
@@ -3057,7 +3085,7 @@ export function apply(ctx, config) {
     };
     const SWEEP_CONCURRENCY = 6;
     const infoTools = createInfoTools({
-        ctx, config, logger, session, lanIp, ownCardUrl, peerStore, taskLedger,
+        ctx, config, logger, session, lanIp, get ownCardUrl() { return ownCardUrl; }, peerStore, taskLedger,
         inFlightRoutes, recentActivity, joinedSessions, sessionNodes, canvasStore,
         teamMemberships, exposureStore, idempotencyStore, cardCache,
         id8, sessionTeamOf,
@@ -3126,6 +3154,7 @@ export function apply(ctx, config) {
                     team: canvasTeamOf(name),
                     session,
                     name,
+                    kind: 'canvas', owner: ownCardUrl, memberCount: canvasStore.membersOf(name).length,
                     description: `canvas team — ${members.length} member${members.length === 1 ? '' : 's'}, ${live} live`,
                     local: true,
                     origin: localOrigin,
@@ -3304,7 +3333,40 @@ export function apply(ctx, config) {
      * caller label — the "能发即能收" invariant: whatever it addresses can
      * answer it with one route.
      */
+    const knownCanvasOwners = () => canvasOwners(canvasStore.list().map(name => ({ name, team: canvasTeamOf(name), members: canvasStore.membersOf(name) })), ownCardUrl, [...cardCache.entries()].flatMap(([url, entry]) => entry.card === undefined ? [] : [{ url, card: entry.card }]));
+    const diagnoseCanvas = async (team, reason, caller) => {
+        if (!new RegExp('^.+/canvas/[^/]+$').test(team))
+            return reason;
+        try {
+            await listDirectoryTeams(false, true);
+        }
+        catch (error) {
+            return reason + ' — canvas discovery unavailable: ' + String(error);
+        }
+        const resolve = localHandleResolver();
+        const localId = caller === undefined ? undefined : resolve(caller);
+        const owners = knownCanvasOwners().filter(row => !ownerTeamScopeInfo || (caller !== undefined && cliDeposits.get(caller) !== undefined) || (row.local ? localId !== undefined && row.members.some(ref => ref === localId || resolve(ref) === localId) : (row.scopeMembers ?? row.members).some(ref => { const id = resolve(ref); return id !== undefined && joinedSessions.has(id); })));
+        const missing = [];
+        if (caller !== undefined && cliDeposits.get(caller) !== undefined) {
+            if (!config.forwardDirect)
+                missing.push('home forwardDirect is off');
+            if (config.isolated)
+                missing.push('home is isolated');
+            const scope = config.teamScopeRouting ? await outboundScope(senderScopeRecords, caller, caller, team) : { ok: true };
+            if (!scope.ok)
+                missing.push('sender scope: ' + scope.error);
+            for (const owner of owners.filter(row => row.team === team && !row.local)) {
+                if (!owner.members.includes(caller))
+                    missing.push(owner.owner + ': caller is not an advertised canvas member');
+                for (const member of owner.members.filter(member => member !== caller))
+                    if (!canvasStore.list().some(name => canvasStore.remoteMembersOf(name).includes(member)))
+                        missing.push(owner.owner + ': missing direct operator link to receiver ' + member);
+            }
+        }
+        return canvasFailure(team, owners, reason) + (missing.length === 0 ? '' : ' — missing prerequisites: ' + missing.join('; '));
+    };
     const forwardDirect = createDirectForward({
+        births: forwardingBirths,
         enabled: () => config.forwardDirect === true, isolated: () => config.isolated, deposited: handle => cliDeposits.get(handle) !== undefined,
         memberLinked: handle => canvasStore.list().some(name => canvasStore.remoteMembersOf(name).includes(handle)),
         scope: (handle, team) => config.teamScopeRouting ? outboundScope(senderScopeRecords, handle, handle, team) : Promise.resolve({ ok: true }),
@@ -3363,7 +3425,7 @@ export function apply(ctx, config) {
                 scopedCanvasCaller = { id: scopeCaller, handle: callerHandle };
                 const scope = await outboundScope(senderScopeRecords, scopeCaller, callerHandle, String(args.team ?? '').trim());
                 if (!scope.ok)
-                    return localRoute(scope);
+                    return localRoute({ ...scope, error: await diagnoseCanvas(args.team, scope.error, callerHandle) });
             }
         }
         let callerSession = resolveCallerLabel({
@@ -3491,7 +3553,8 @@ export function apply(ctx, config) {
         }
         if (failures.length > 0)
             logger.warn(`route to team "${args.team}" exhausted its candidates: ${failures.join('; ')}`);
-        return routeVerdict(args.team, failures, candidatePool.length);
+        const verdict = routeVerdict(args.team, failures, candidatePool.length);
+        return { ...verdict, error: await diagnoseCanvas(args.team, verdict.error, callerSession) };
     }
     /**
      * The route dispatcher's local half: same-host candidates dial in-process,

package/lib/origin-claim.js

@@ -210,7 +210,7 @@ export async function verifyOriginClaim(req, d) {
             return;
         d.onUnbound();
         if (hasBound)
-            d.onBoundMiss?.();
+            d.onBoundMiss?.({ caller, audience: originOf(audience) });
     };
     // gh#133: a CLI identity deposited HERE, decided from the deposit table
     // before any fetch (the CLI may reach its home through a proxy the host

package/lib/peer-directory.js

@@ -109,7 +109,7 @@ export function peerDirectoryRows(card, peer, includeCanvas) {
     if (includeCanvas)
         for (const entry of advertisedCanvasTeams(card)) {
             const declared = rosterOf.get(entry.team);
-            rows.push({ team: entry.team, session: card.session, name: entry.name, description: 'canvas team', origin, via: peer, ...(legacy ? { legacy } : {}), ...(declared !== undefined && declared.length > 0 ? { teams: declared } : {}), canvasMembers: entry.members.filter(ref => !publishedSessions.has(ref)) });
+            rows.push({ team: entry.team, session: card.session, name: entry.name, description: 'canvas team', kind: 'canvas', owner: peer, memberCount: entry.members.length, origin, via: peer, ...(legacy ? { legacy } : {}), ...(declared !== undefined && declared.length > 0 ? { teams: declared } : {}), canvasMembers: entry.members.filter(ref => !publishedSessions.has(ref)) });
         }
     return rows;
 }

package/lib/skill/references/cli.md

@@ -121,9 +121,9 @@ Files do not go through session messages: use the file channel below, never JPFI
   - Reusing an id for a different message, or switching `--sync` on or off,
     is refused (exit 1): drop `--task` to send it as a new task.
   - `report` takes `--task` the same way.
-- Home-host forwarding is opt-in: `forwardDirect: true` forwards one hop only after a local target miss. H must not be isolated, the CLI must be online and sign a bound envelope, the inbound request must have no Guard, and the target must pass H’s sender scope.
+- From 0.6.38 home-host forwarding defaults on (`forwardDirect: true`); explicit `false` restores local-only delivery. It forwards one hop only after a local target miss. H must not be isolated, the CLI must be online and sign a bound envelope, the inbound request must have no Guard, and the target must pass H’s sender scope.
 - Both operators establish links: at A, put the CLI and B receiving member handles in an operator canvas; at B, link the CLI handle and pin its home to A. A remote canvas target requires A to directly link every advertised receiving member; a peer-org claim alone is insufficient for the return receipt.
-- B signs its auto-receipt as the member that did the work. Its destination prefers an online CLI household on that host (an owner-controlled fact); otherwise it returns only to the pinned home, never another directory advertiser. In the normal single-home setup it settles A’s single forwarded outbound row on-chain under `enforce` and enters the CLI mailbox (`a2a-net inbox`). `--sync` returns B’s final reply. A 15s transport-budget expiry is `-32005`; reconcile by task id rather than resend blindly.
+- B signs its auto-receipt as the member that did the work. Its destination prefers an online CLI household on that host (an owner-controlled fact); otherwise it returns only to the pinned home, never another directory advertiser. In the normal single-home setup it settles A’s single forwarded outbound row on-chain under `enforce` and enters the CLI mailbox (`a2a-net inbox`). `--sync` returns B’s final reply. The transport still has a 15s synchronous patience window, not a full model-turn budget. For forwarded or long work, prefer `a2a-net route <team> <message>` (async by default) then `a2a-net inbox --wait --renew`. A `--sync` transport expiry is `-32005`; the target still auto-receipts the original task after finishing. Reconcile by task id/inbox instead of treating a new direct pong as its receipt or resending blindly.
 - With forwarding off or any prerequisite missing, the original "No live DSH session node accepts team" error includes the reason it was not forwarded. Receiving hosts never forward the forwarded request again.
 - Admission: a deposited handle is a node fact of its home host (N3); that fact alone grants no remote scope or admission. Operator canvas membership and B’s home pin are still required. Global self-description is never a link.
 - `a2a-net report <message…>` is a one-way report to the host's process team.
@@ -169,9 +169,13 @@ Files do not go through session messages: use the file channel below, never JPFI
 
 ## Reading the host
 
+If configured enforcement is refused because old forwarded canvas debts lack receiver facts, the plugin stays online in observe. `tasks --json` preserves `settlement.mode` and `settlement.enforceRefused:{reason,blockers}`; tasks/status text also shows the refusal. This boot-time audit remains after reconciliation; a later owner-controlled reapplication may enable enforce once blockers are cleared. Configuration on disk is unchanged.
+
 `whoami`, `teams [query]`, `status`, `tasks`, `probe` read the home host's
 state face (key-gated on a keyed host). `--json` prints raw rows for
-`teams`, `tasks`, `probe`, `route`, `report`, `inbox` and `skills`.
+`whoami`, `teams`, `tasks`, `probe`, `route`, `report`, `inbox` and `skills`.
+
+`teams` includes local canvas and peerOrg rows with qualified route name, owner URL and memberCount; same names on different hosts stay separate. `whoami --json` is pure JSON and includes only canvases naming this CLI identity, local and remote. An unreadable optional state face reports canvasError/UNKNOWN, never falsely empty membership. Canvas failures retain the original refusal and add visible-directory not-found, owner prerequisites (including each missing direct receiver link), or conflicting owner candidates. Owner URLs do not require direct dialing or a home override and grant no admission.
 
 ## Local commands
 

package/lib/skill/references/pitfalls.md

@@ -24,7 +24,7 @@
   The `a2a-net` CLI (0.6.27+) is the supported exception: a DEPOSITED handle
   is routable on its home host and receives into its mailbox
   ([cli.md](cli.md)).
-- **"No live DSH session node accepts team" may name a forwarding prerequisite.** Direct delivery remains local by default. `forwardDirect: true` permits one hop only for an online, bound-signed local CLI, on a non-isolated home, with no inbound Guard and a target inside sender scope. A must link B’s receiving members; B must link the CLI and pin A as its home. Remote canvas org alone cannot authorize the receipt return path. Read the appended "not forwarded" reason; do not treat a missing link, expired deposit or already-forwarded request as a transport outage. The target host never forwards again.
+- **"No live DSH session node accepts team" may name a forwarding prerequisite.** From 0.6.38 `forwardDirect` defaults on; explicit `false` disables it. It permits one hop only for an online, bound-signed local CLI, on a non-isolated home, with no inbound Guard and a target inside sender scope. A must link B’s receiving members; B must link the CLI and pin A as its home. Remote canvas org alone cannot authorize the receipt return path. Read the appended "not forwarded" reason; do not treat a missing link, expired deposit or already-forwarded request as a transport outage. The target host never forwards again.
 - A sync route to a remote peer rides a 15s transport budget (a target on
   this host gets 180s) — both are shorter than many model turns. For
   anything that runs long, prefer `async: true` and the receipt contract.

package/lib/skill/references/setup.md

@@ -115,14 +115,11 @@ Do section 1 on both hosts first. Then the **owner**, on BOTH hosts:
 
 ## 3. Beyond direct peers (A cannot reach C)
 
-Host-to-host forwarding is **not shipped yet**. Today a delivery reaches only
-the host it is sent to:
-- `/a2a/direct` never relays.
-- A session's `a2a_route` dials the host that publishes the team.
-- #57 Plan A (host forwarding) is designed. Its prerequisite #60 hop budget
-  has landed at ingress.
+Home-host one-hop forwarding shipped in 0.6.34 and defaults **on from 0.6.38**. Explicit `forwardDirect: false` restores local-only CLI delivery. It only follows a local miss for a bound-signed, online CLI deposited on that home, inside the unchanged sender scope. A must directly link B's receiving member (all advertised potential receivers for a canvas), and B must link the CLI and pin A as home. The home must not be isolated and any inbound Guard prevents a second forward. The outbound hop budget remains DEFAULT-1. No links are auto-created or relaxed.
 
-Until forwarding ships, pick one:
+Long forwarded work should use async `route` plus `inbox --wait --renew`, not expect a 15s `--sync` transport window to cover an entire model turn. A late final still produces the original task's receipt, and the forwarded row keeps selected-peer receiver facts for enforced settlement.
+
+Other connectivity options (not authority bypasses):
 
 1. **Make it a peer pair.** Open a tunnel or port-forward so A reaches C,
    then do section 2 for A↔C. This is the simplest and keeps receipts
@@ -139,8 +136,7 @@ Until forwarding ships, pick one:
 ## 4. Callers outside a session
 
 Scripts and terminals use the `a2a-net` CLI: deposit on ONE home host, read
-a mailbox, no wake. The same rule applies: the CLI reaches only teams on its
-home host. See [cli.md](cli.md).
+a mailbox, no wake. The home can forward eligible requests one hop under section 3; an online deposit alone grants no remote scope. See [cli.md](cli.md).
 
 ## 5. Symptom → step
 

package/lib/task-auth.js

@@ -487,7 +487,7 @@ export function judgeSettlement(row, settler, facts) {
         return { ok: true, role: 'legacy' };
     const target = inbound ? row.auth.target : row.team;
     // #139: once the member that received the task is known, it alone answers for the team.
-    const members = row.deliveredTo !== undefined ? [row.deliveredTo] : facts.membersOf(target) ?? [];
+    const members = row.deliveredTo !== undefined ? [row.deliveredTo] : row.forwarded === true ? row.receiverMembers ?? [] : facts.membersOf(target) ?? [];
     const local = inbound || row.peer === 'local' || row.peer.startsWith('local:');
     const peerOrigin = local ? undefined : originOfUrl(row.peer);
     // #139: the peer is its signing key, not one spelling of its address — a host

package/lib/task-ledger-rows.js

@@ -91,12 +91,17 @@ export function withAuth(raw, entry, now) {
         return {};
     if (entry.direction === 'inbound')
         return auth.ingress === 'wire' && `local:${auth.receipt_target}` === entry.peer ? { auth } : {};
-    // #139: an outbound row carries only its local-candidate admission.
+    // Forwarded births retain the verified local CLI wire admission for audit, never borrowed remote authority.
+    if (entry.forwarded === true && typeof entry.peer === 'string' && !entry.peer.startsWith('local')) {
+        const sender = parseSender(entry.sender);
+        return auth.ingress === 'wire' && auth.proof === 'cli-identity' && sender?.kind === 'cli' && sender.id === auth.caller && auth.receipt_target === auth.caller ? { auth } : {};
+    }
     return auth.ingress === 'local' && entry.peer === 'local' ? { auth } : {};
 }
 /** Routing and answer facts copied unchanged between a row and its archive entry. */
 export function routingOf(row) {
     return {
+        ...(row.receiverMembers !== undefined ? { receiverMembers: [...row.receiverMembers] } : {}),
         ...(row.answeredAt !== undefined ? { answeredAt: row.answeredAt } : {}),
         ...(row.forwarded === true ? { forwarded: true } : {}),
         ...(row.peerKey !== undefined ? { peerKey: row.peerKey } : {}),
@@ -105,13 +110,15 @@ export function routingOf(row) {
     };
 }
 /** The facts of one outbound birth that fit the row (see {@link withRouting} for the same shape on restore). */
-export function birthFacts(peer, birth) {
+export function birthFacts(peer, birth, team = '', sender, now = Date.now(), warn = console.warn) {
     if (birth === undefined)
         return {};
     const fact = (v) => v !== undefined && v !== '' && v.length <= ROUTING_FACT_CAP;
     const remote = peer !== 'local' && !peer.startsWith('local:');
+    const receiverMembers = remote && birth.forwarded === true && fact(birth.peerKey) ? parseReceiverMembers(birth.receiverMembers, warn) : undefined;
     return {
-        ...(!remote && birth.auth !== undefined && birth.auth.ingress === 'local' ? { auth: birth.auth } : {}),
+        ...withAuth(birth.auth, { direction: 'outbound', team, peer, sender, forwarded: birth.forwarded }, now),
+        ...(receiverMembers !== undefined ? { receiverMembers } : {}),
         ...(remote && birth.forwarded === true ? { forwarded: true } : {}),
         ...(remote && fact(birth.peerKey) ? { peerKey: birth.peerKey } : {}),
         ...(remote && fact(birth.peerHost) ? { peerHost: birth.peerHost } : {}),
@@ -120,17 +127,38 @@ export function birthFacts(peer, birth) {
 }
 /** Bound on a persisted routing fact; anything longer (or empty, or not a string) is dropped on restore. */
 export const ROUTING_FACT_CAP = 256;
+export function parseReceiverMembers(value, warn = console.warn) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        warn('a2a: receiverMembers is not an array; ignored');
+        return undefined;
+    }
+    const members = new Set();
+    if (value.length > 256)
+        warn('a2a: receiverMembers exceeds 256 entries; tail ignored');
+    for (const [index, member] of value.slice(0, 256).entries()) {
+        if (typeof member !== 'string' || !new RegExp('^[a-z0-9-]+/[0-9a-f]{8}(?:[0-9a-f]{8})?$', 'i').test(member)) {
+            warn('a2a: invalid receiverMembers entry at index ' + index + '; ignored');
+            continue;
+        }
+        members.add(member);
+    }
+    return members.size === 0 ? undefined : Object.freeze([...members]);
+}
 /**
  * #139: restore-side allowlist for the routing facts. Each is kept only in
  * its shape — a non-empty string within the cap — and the peer facts only on
  * a remote outbound row; anything else is dropped (the row survives as one
  * born before the fields, judged by current membership and origin).
  */
-export function withRouting(entry) {
+export function withRouting(entry, warn = console.warn) {
     const fact = (v) => typeof v === 'string' && v !== '' && v.length <= ROUTING_FACT_CAP;
     const remoteOutbound = entry.direction === 'outbound' && typeof entry.peer === 'string' && entry.peer !== 'local' && !entry.peer.startsWith('local:');
+    const receiverMembers = remoteOutbound && entry.forwarded === true && fact(entry.peerKey) ? parseReceiverMembers(entry.receiverMembers, warn) : undefined;
     return {
         ...(typeof entry.answeredAt === 'number' && Number.isFinite(entry.answeredAt) && entry.answeredAt >= 0 ? { answeredAt: entry.answeredAt } : {}),
+        ...(receiverMembers !== undefined ? { receiverMembers } : {}),
         ...(remoteOutbound && entry.forwarded === true ? { forwarded: true } : {}),
         ...(remoteOutbound && fact(entry.peerKey) ? { peerKey: entry.peerKey } : {}),
         ...(remoteOutbound && fact(entry.peerHost) ? { peerHost: entry.peerHost } : {}),

package/lib/task-ledger.js

@@ -46,6 +46,7 @@ export class TaskLedger {
     archiveCap;
     /** Injectable clock (option `now`). */
     now;
+    warn;
     /**
      * @param path - persistence file (`<dsh-home>/a2a/tasks.json`); empty = no persistence.
      * @param options - TTL/capacity overrides; defaults come from the exported constants.
@@ -55,6 +56,7 @@ export class TaskLedger {
         this.staleTtlMs = options?.staleTtlMs ?? TASK_STALE_TTL_MS;
         this.archiveCap = options?.archiveCap ?? ARCHIVE_CAP;
         this.now = options?.now ?? (() => Date.now());
+        this.warn = options?.warn ?? console.warn;
         this.restore();
     }
     /**
@@ -66,6 +68,10 @@ export class TaskLedger {
         this.sweep(this.now());
         return [...this.tasks];
     }
+    /** #275: old forwarded canvas debts cannot be safely upgraded by inventing receiver authority. */
+    settlementEnforceBlockers() {
+        return this.list().filter(row => row.direction === 'outbound' && row.forwarded === true && row.receiptExpected !== false && row.team.includes('/canvas/') && (row.deliveredTo === row.team || (row.deliveredTo === undefined && (row.receiverMembers === undefined || row.receiverMembers.length === 0)))).map(row => row.taskId);
+    }
     /**
      * The settled archive, most recently resolved first. Rows land here the
      * moment their receipt correlates and stay until the archive cap evicts
@@ -113,7 +119,7 @@ export class TaskLedger {
                 ...(contextId !== undefined && contextId !== '' ? { contextId } : {}),
                 ...(brief !== undefined && brief !== '' ? { brief } : {}),
                 ...(sender !== undefined ? { sender } : {}),
-                ...birthFacts(peer, birth),
+                ...birthFacts(peer, birth, team, sender, this.now(), this.warn),
                 status: 'pending',
             }, ...this.tasks];
         this.trimOwed();
@@ -137,7 +143,7 @@ export class TaskLedger {
                 ...(contextId !== undefined && contextId !== '' ? { contextId } : {}),
                 ...(brief !== undefined && brief !== '' ? { brief } : {}),
                 ...(sender !== undefined ? { sender } : {}),
-                ...birthFacts(peer, birth),
+                ...birthFacts(peer, birth, team, sender, this.now(), this.warn),
                 status: 'pending',
             }, ...this.tasks];
         this.trimOwed();
@@ -629,7 +635,7 @@ export class TaskLedger {
                             ...(entry.receiptExpected === false ? { receiptExpected: false } : {}),
                             ...withSender(entry.sender, entry.direction),
                             ...withAuth(entry.auth, entry, this.now()),
-                            ...withRouting(entry),
+                            ...withRouting(entry, this.warn),
                             ...withSettledBy(entry.settledBy),
                         });
                         continue;
@@ -648,7 +654,7 @@ export class TaskLedger {
                         // #114 S3: a malformed sender is dropped whole; the row survives.
                         ...withSender(entry.sender, entry.direction),
                         ...withAuth(entry.auth, entry, this.now()),
-                        ...withRouting(entry),
+                        ...withRouting(entry, this.warn),
                         status: entry.status === 'dead' ? 'dead' : 'pending',
                         ...(entry.status === 'dead'
                             ? {
@@ -686,7 +692,7 @@ export class TaskLedger {
                         ...(entry.receiptExpected === false ? { receiptExpected: false } : {}),
                         ...withSender(entry.sender, entry.direction),
                         ...withAuth(entry.auth, entry, this.now()),
-                        ...withRouting(entry),
+                        ...withRouting(entry, this.warn),
                         ...withSettledBy(entry.settledBy),
                     });
                 }

package/lib/tools/info.js

@@ -9,6 +9,7 @@
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { peerDirectoryRows } from "../peer-directory.js";
+import { canvasMemberships, canvasOwners } from "../canvas-discovery.js";
 import { peerContentMeta } from "../node-self.js";
 /**
  * Build the five registrars. Call createInfoTools after its deps exist, then
@@ -16,7 +17,7 @@ import { peerContentMeta } from "../node-self.js";
  * registry order the model sees must not change.
  */
 export function createInfoTools(deps) {
-    const { ctx, config, logger, session, lanIp, ownCardUrl, peerStore, taskLedger, joinedSessions, teamMemberships, canvasStore, exposureStore, idempotencyStore, cardCache, inFlightRoutes, recentActivity, teamAuditRing, reportRing, sessionNodes, id8, sessionTeamOf, nodeMetadataOf, canvasTeamOf, canvasTeamsOfSession, localHandleResolver, memoizedCardFetch, mapBounded, SWEEP_CONCURRENCY, a2aJoinGateRefusal, observeAuthorization, settlePeerCard, client, listDirectoryTeams, } = deps;
+    const { ctx, config, logger, session, lanIp, peerStore, taskLedger, joinedSessions, teamMemberships, canvasStore, exposureStore, idempotencyStore, cardCache, inFlightRoutes, recentActivity, teamAuditRing, reportRing, sessionNodes, id8, sessionTeamOf, nodeMetadataOf, canvasTeamOf, canvasTeamsOfSession, localHandleResolver, memoizedCardFetch, mapBounded, SWEEP_CONCURRENCY, a2aJoinGateRefusal, observeAuthorization, settlePeerCard, client, listDirectoryTeams, } = deps;
     // S5 (owner directive 2026-10-20): information-plane scoping. The host's
     // joined-team scope is the union of every local node's roster
     // declarations — a host-level set, not per-session: supervisor seats need
@@ -104,7 +105,7 @@ export function createInfoTools(deps) {
                         teams: {
                             type: 'object',
                             additionalProperties: true,
-                            description: 'roster: allowlisted teams declared via a2a_team_join; canvas: workbench-assigned teams.',
+                            description: 'roster: allowlisted teams declared via a2a_team_join; canvas: local workbench-assigned names (compatibility); canvasDetails: local/remote membership with qualified team, owner URL and memberCount.',
                         },
                         allowlist: {
                             type: 'object',
@@ -124,7 +125,7 @@ export function createInfoTools(deps) {
                         type: 'text',
                         text: value.face === 'host'
                             ? `Host face on team ${String(value.node?.team ?? '?')}: routing rides the bare node team (能发即能收)`
-                            : `Node ${String(value.node?.name ?? '')} ${String(value.node?.id ?? '?')}: joined=${String(value.node?.joined)}, live=${String(value.node?.live)}; roster teams: ${(value.teams?.roster ?? []).join(', ') || 'none'}; canvas: ${(value.teams?.canvas ?? []).join(', ') || 'none'}; allowlist effect: ${String(value.allowlist?.effect ?? '?')}`,
+                            : `Node ${String(value.node?.name ?? '')} ${String(value.node?.id ?? '?')}: joined=${String(value.node?.joined)}, live=${String(value.node?.live)}; roster teams: ${(value.teams?.roster ?? []).join(', ') || 'none'}; canvas: ${(value.teams?.canvas ?? []).join(', ') || 'none'}; canvas owners: ${JSON.stringify(value.teams?.canvasDetails ?? [])}; allowlist effect: ${String(value.allowlist?.effect ?? '?')}`,
                     }],
             },
             presentCall: () => ({ card: 'generic', title: 'A2A whoami', kind: 'other', rawInput: null }),
@@ -140,6 +141,8 @@ export function createInfoTools(deps) {
                 }
                 const joined = joinedSessions.has(agentId);
                 const live = sessionNodes.has(agentId);
+                await listDirectoryTeams(false, true); // refresh through the existing bounded directory, not a second discovery path
+                const canvasDetails = canvasMemberships(canvasOwners(canvasStore.list().map(name => ({ name, team: canvasTeamOf(name), members: canvasStore.membersOf(name) })), deps.ownCardUrl, [...cardCache.entries()].flatMap(([url, entry]) => entry.card === undefined ? [] : [{ url, card: entry.card }])), `${config.team}/${id8(agentId)}`, agentId, localHandleResolver());
                 const refusals = teamAuditRing
                     .filter(entry => entry.id === agentId && !entry.ok)
                     .slice(-3)
@@ -159,6 +162,7 @@ export function createInfoTools(deps) {
                     teams: {
                         roster: [...teamMemberships.teamsOf(agentId)],
                         canvas: [...canvasTeamsOfSession(agentId)],
+                        canvasDetails,
                     },
                     allowlist: {
                         patterns,
@@ -211,6 +215,9 @@ export function createInfoTools(deps) {
                                     session: { type: 'string', required: true },
                                     name: { type: 'string', required: true },
                                     seatName: { type: 'string', description: 'Human-owned stable display label, never a route identity.' },
+                                    kind: { type: 'string', enum: ['canvas'] },
+                                    owner: { type: 'string', description: 'Canvas owner host URL; discovery metadata, not a --home requirement.' },
+                                    memberCount: { type: 'number' },
                                     description: { type: 'string', required: true },
                                     local: { type: 'boolean', description: 'true when the team is served by this host (loopback candidate).' },
                                     origin: { type: 'string', description: 'The publishing host (node session label, LAN IP when known) — the natural grouping for fleet rows.' },
@@ -228,7 +235,7 @@ export function createInfoTools(deps) {
                         type: 'text',
                         text: (value.teams.length === 0
                             ? `No A2A teams${(value.query ?? '') === '' ? '' : ` matching "${String(args.query)}"`} are currently reachable.`
-                            : value.teams.map(team => `- ${team.team}${team.local === true ? ' [this host]' : ''}${team.name === '' ? '' : ` (${team.name})`}${team.description === '' ? '' : ` — ${team.description}`}${typeof team.origin === 'string' && team.origin !== '' && team.local !== true ? ` @ ${team.origin}` : ''}${typeof team.workspace === 'string' && team.workspace !== '' ? ` [${team.workspace}]` : ''}`).join('\n'))
+                            : value.teams.map(team => `- ${team.team}${team.local === true ? ' [this host]' : ''}${team.name === '' ? '' : ` (${team.name})`}${team.kind === 'canvas' ? ` [canvas owner=${team.owner ?? '?'} members=${String(team.memberCount ?? '?')}]` : ''}${team.description === '' ? '' : ` — ${team.description}`}${typeof team.origin === 'string' && team.origin !== '' && team.local !== true ? ` @ ${team.origin}` : ''}${typeof team.workspace === 'string' && team.workspace !== '' ? ` [${team.workspace}]` : ''}`).join('\n'))
                             + (value.note === undefined ? '' : `\n${value.note}`),
                     }],
             },
@@ -301,7 +308,7 @@ export function createInfoTools(deps) {
                     return { ok: true, query: '', teams, ...(note !== undefined ? { note } : {}) };
                 const matches = (team) => team.team.toLowerCase().includes(query) || team.name.toLowerCase().includes(query) || team.description.toLowerCase().includes(query)
                     || team.session.toLowerCase().includes(query)
-                    || (team.origin ?? '').toLowerCase().includes(query) || (team.workspace ?? '').toLowerCase().includes(query) || (team.via ?? '').toLowerCase().includes(query);
+                    || (team.owner ?? '').toLowerCase().includes(query) || (team.origin ?? '').toLowerCase().includes(query) || (team.workspace ?? '').toLowerCase().includes(query) || (team.via ?? '').toLowerCase().includes(query);
                 return { ok: true, query, teams: teams.filter(matches), ...(note !== undefined ? { note } : {}) };
             },
         }));

package/lib/types/canvas-discovery.d.ts

@@ -0,0 +1,20 @@
+import type { A2aPeerCard } from './types.ts';
+export interface CanvasOwner {
+    team: string;
+    name: string;
+    owner: string;
+    memberCount: number;
+    local: boolean;
+    members: readonly string[];
+    scopeMembers?: readonly string[];
+}
+export declare function canvasOwners(local: readonly {
+    name: string;
+    team: string;
+    members: readonly string[];
+}[], ownUrl: string, peers: readonly {
+    url: string;
+    card: A2aPeerCard;
+}[]): CanvasOwner[];
+export declare function canvasMemberships(owners: readonly CanvasOwner[], handle: string, localId?: string, resolveLocal?: (ref: string) => string | undefined): Omit<CanvasOwner, 'members' | 'scopeMembers'>[];
+export declare function canvasFailure(team: string, owners: readonly CanvasOwner[], reason: string): string;

package/lib/types/direct-forward.d.ts

@@ -1,4 +1,5 @@
 import { type TaskLedger } from './task-ledger.ts';
+import type { TaskAuthorization } from './task-auth.ts';
 import type { A2aPeerCard, A2aRouteResult } from './types.ts';
 export interface ForwardRequest {
     team: string;
@@ -9,8 +10,16 @@ export interface ForwardRequest {
     noWait: boolean;
     localCliProof: boolean;
     guarded: boolean;
+    auth?: TaskAuthorization;
+}
+/** Birth barrier exists only for eligible, actively dispatched tasks; receipts never reserve a slot. */
+export declare class ForwardBirths {
+    private readonly pending;
+    wait(taskId: string): Promise<void> | undefined;
+    begin(taskId: string): (() => void) | undefined;
 }
 export interface DirectForwardDeps {
+    births: ForwardBirths;
     enabled(): boolean;
     isolated(): boolean;
     deposited(handle: string): boolean;