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

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

@@ -0,0 +1,220 @@
+/** Stateless ledger row types, classifiers and restore projections; moved verbatim for #258. */
+import { parseAuthorization } from "./task-auth.js";
+/**
+ * Caller-ended summaries (abandon / cancel) share one isolation law: late
+ * receipts never rewrite the verdict — they only stamp lateReceiptAt, and
+ * the projected outcome collapses to 'abandoned'.
+ */
+export const CALLER_ENDED_PREFIX = /^caller-(abandoned|cancelled)/;
+/** Hard cap on the owed book (pending + dead-lettered rows, most recent first). */
+export const TASK_CAP = 64;
+/** Hard cap on the settled archive (most recent kept). */
+export const ARCHIVE_CAP = 64;
+/** Longest receipt summary kept on a record (multi-line outcomes collapse). */
+export const SUMMARY_CAP = 200;
+/**
+ * Longest dispatch brief kept per row. A ledger row without its payload is
+ * unreadable to supervision — "direct-8f3a1c2b → dsh/ec4ce7f8, 3h old" says
+ * nothing about whether to nudge, abandon, or read the receipt. The brief is
+ * the first non-empty line of the message, capped; the full body never enters
+ * the ledger (it can be arbitrarily large and may quote another session's log).
+ */
+export const BRIEF_CAP = 120;
+/** Reduce a dispatch body to one readable line: first non-empty line, collapsed, capped. */
+export function briefOf(message) {
+    if (message === undefined)
+        return undefined;
+    for (const raw of message.split('\n')) {
+        const line = raw.trim().replace(/\s+/g, ' ');
+        if (line !== '')
+            return line.length <= BRIEF_CAP ? line : `${line.slice(0, BRIEF_CAP - 1)}…`;
+    }
+    return undefined;
+}
+/**
+ * Age at which an unsettled task auto-dead-letters. A dead row exits the
+ * owed view, disarms its async-nudge retry (a cold session cannot consume a
+ * re-steer anyway), and still accepts a late receipt from a revived target.
+ * Injectable per instance so tests can use short windows; sweeping stays
+ * lazy — every read/write entry point sweeps first.
+ */
+export const TASK_STALE_TTL_MS = 24 * 60 * 60_000;
+export const ARCHIVE_ENDS = ['receipt', 'echo', 'abandoned', 'cancelled', 'evicted'];
+/** Summary marker {@link TaskLedger.resolveEcho} writes on echo-settled rows. */
+export const ECHO_SUMMARY = '(settled by content echo)';
+const SENDER_KINDS = ['session', 'host', 'bridge', 'cli'];
+/** Longest sender id kept; anything longer is malformed, not truncated. */
+export const SENDER_ID_CAP = 256;
+/**
+ * Restore-side allowlist for one persisted sender: a well-formed value comes
+ * back as a fresh object holding only kind, id and (when present) face; anything else is dropped whole (the row
+ * itself survives — a bad sender never costs the debt record).
+ * @param raw - the persisted value.
+ * @returns the sender, or undefined when absent or malformed.
+ */
+export function parseSender(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const { kind, id, face } = raw;
+    if (typeof kind !== 'string' || !SENDER_KINDS.includes(kind))
+        return undefined;
+    if (typeof id !== 'string' || id === '' || id.length > SENDER_ID_CAP)
+        return undefined;
+    if (face !== undefined && (typeof face !== 'string' || face === '' || face.length > SENDER_ID_CAP))
+        return undefined;
+    // `face` belongs to host senders only; on any other kind it is dropped, the sender kept.
+    return { kind: kind, id, ...(face !== undefined && kind === 'host' ? { face } : {}) };
+}
+/**
+ * Spread helper for restore: `{ sender }` when the persisted value parses and
+ * the row is not inbound (an inbound row's originator is its caller, never a
+ * sender this host recorded), else nothing.
+ */
+export function withSender(raw, direction) {
+    if (direction === 'inbound')
+        return {};
+    const sender = parseSender(raw);
+    return sender === undefined ? {} : { sender };
+}
+/**
+ * #114 S2: `{ auth }` when a persisted INBOUND row carries a record that
+ * parses whole (parseAuthorization) and belongs to THIS row — its target is
+ * the row's team and its receipt target the row's peer — else nothing: the
+ * row survives as a pre-S2 row, never with a partially adopted or borrowed
+ * record.
+ */
+export function withAuth(raw, entry, now) {
+    if (entry.direction !== 'inbound' && entry.direction !== 'outbound')
+        return {};
+    const auth = parseAuthorization(raw, now);
+    if (auth === undefined || auth.target !== entry.team)
+        return {};
+    if (entry.direction === 'inbound')
+        return auth.ingress === 'wire' && `local:${auth.receipt_target}` === entry.peer ? { auth } : {};
+    // 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 } : {}),
+        ...(row.peerHost !== undefined ? { peerHost: row.peerHost } : {}),
+        ...(row.deliveredTo !== undefined ? { deliveredTo: row.deliveredTo } : {}),
+    };
+}
+/** The facts of one outbound birth that fit the row (see {@link withRouting} for the same shape on restore). */
+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 {
+        ...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 } : {}),
+        ...(fact(birth.deliveredTo) ? { deliveredTo: birth.deliveredTo } : {}),
+    };
+}
+/** 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, 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 } : {}),
+        ...(fact(entry.deliveredTo) ? { deliveredTo: entry.deliveredTo } : {}),
+    };
+}
+/**
+ * How one archived row ended (gh#31). The recorded field wins; legacy rows
+ * fall back to the summary markers this ledger writes itself. The fallback
+ * reads a receipt-settled row's summary, which is the peer's text, so it is
+ * only as exact as the legacy data allows.
+ * @param row - the archived record.
+ * @returns the archive path that ended it.
+ */
+export function archivedEndedBy(row) {
+    if (row.endedBy !== undefined)
+        return row.endedBy;
+    const summary = row.summary ?? '';
+    if (summary.startsWith('caller-cancelled'))
+        return 'cancelled';
+    if (summary.startsWith('caller-abandoned'))
+        return 'abandoned';
+    if (summary === ECHO_SUMMARY)
+        return 'echo';
+    return 'receipt';
+}
+/** Bound on ids and callers kept in settlement records; longer values are cut on write and refused on restore. */
+export const SETTLEMENT_ID_CAP = 256;
+/** Bound of the refusal ring (design §4.4). */
+export const SETTLEMENT_REFUSAL_CAP = 64;
+const SETTLEMENT_REASONS = ['settler-off-chain', 'settler-unverified', 'on-behalf-mismatch', 'echo-off-chain'];
+const CHAIN_ROLES = ['target', 'target-member', 'host-face', 'compat', 'legacy', 'off-chain'];
+const PROOF_VALUES = ['origin-claim', 'claim-mismatch', 'legacy-window', 'unbound', 'cli-identity', 'in-process', 'none'];
+/** Restore-side allowlist for settledBy: whole or nothing. */
+export function withSettledBy(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return {};
+    const r = raw;
+    if (typeof r.caller !== 'string' || r.caller.length > SETTLEMENT_ID_CAP || typeof r.chain_role !== 'string' || !CHAIN_ROLES.includes(r.chain_role))
+        return {};
+    return { settledBy: { caller: r.caller, chain_role: r.chain_role } };
+}
+/** Restore-side allowlist for one refusal record: whole or nothing. */
+export function parseRefusal(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return undefined;
+    const r = raw;
+    const st = r.settler;
+    if (typeof r.taskId !== 'string' || r.taskId === '' || r.taskId.length > SETTLEMENT_ID_CAP || typeof r.at !== 'number' || !Number.isFinite(r.at))
+        return undefined;
+    if (typeof r.reason !== 'string' || !SETTLEMENT_REASONS.includes(r.reason) || typeof r.head !== 'string' || typeof r.enforced !== 'boolean')
+        return undefined;
+    if (st === null || typeof st !== 'object' || typeof st.caller !== 'string' || st.caller.length > SETTLEMENT_ID_CAP || typeof st.proof !== 'string' || !PROOF_VALUES.includes(st.proof) || (st.ingress !== 'wire' && st.ingress !== 'local'))
+        return undefined;
+    const count = r.count === undefined ? 1 : r.count;
+    if (typeof count !== 'number' || !Number.isInteger(count) || count < 1)
+        return undefined;
+    return { taskId: r.taskId, at: r.at, settler: { caller: st.caller, proof: st.proof, ingress: st.ingress }, reason: r.reason, head: r.head.slice(0, SUMMARY_CAP), enforced: r.enforced, count };
+}

package/lib/task-ledger.js

@@ -18,201 +18,12 @@
  * illusion: settlements vanished while debts piled up).
  * @module @nelsonlongxiang/dsh-open-a2a-net/task-ledger
  */
-import { parseAuthorization } from "./task-auth.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { parseReceipt, RECEIPT_OUTCOMES } from "./receipt.js";
 import { classifyConservationBlock, ConservationCounters } from "./ledger-conservation.js";
-/**
- * Caller-ended summaries (abandon / cancel) share one isolation law: late
- * receipts never rewrite the verdict — they only stamp lateReceiptAt, and
- * the projected outcome collapses to 'abandoned'.
- */
-const CALLER_ENDED_PREFIX = /^caller-(abandoned|cancelled)/;
-/** Hard cap on the owed book (pending + dead-lettered rows, most recent first). */
-export const TASK_CAP = 64;
-/** Hard cap on the settled archive (most recent kept). */
-export const ARCHIVE_CAP = 64;
-/** Longest receipt summary kept on a record (multi-line outcomes collapse). */
-export const SUMMARY_CAP = 200;
-/**
- * Longest dispatch brief kept per row. A ledger row without its payload is
- * unreadable to supervision — "direct-8f3a1c2b → dsh/ec4ce7f8, 3h old" says
- * nothing about whether to nudge, abandon, or read the receipt. The brief is
- * the first non-empty line of the message, capped; the full body never enters
- * the ledger (it can be arbitrarily large and may quote another session's log).
- */
-export const BRIEF_CAP = 120;
-/** Reduce a dispatch body to one readable line: first non-empty line, collapsed, capped. */
-export function briefOf(message) {
-    if (message === undefined)
-        return undefined;
-    for (const raw of message.split('\n')) {
-        const line = raw.trim().replace(/\s+/g, ' ');
-        if (line !== '')
-            return line.length <= BRIEF_CAP ? line : `${line.slice(0, BRIEF_CAP - 1)}…`;
-    }
-    return undefined;
-}
-/**
- * Age at which an unsettled task auto-dead-letters. A dead row exits the
- * owed view, disarms its async-nudge retry (a cold session cannot consume a
- * re-steer anyway), and still accepts a late receipt from a revived target.
- * Injectable per instance so tests can use short windows; sweeping stays
- * lazy — every read/write entry point sweeps first.
- */
-export const TASK_STALE_TTL_MS = 24 * 60 * 60_000;
-const ARCHIVE_ENDS = ['receipt', 'echo', 'abandoned', 'cancelled', 'evicted'];
-/** Summary marker {@link TaskLedger.resolveEcho} writes on echo-settled rows. */
-const ECHO_SUMMARY = '(settled by content echo)';
-const SENDER_KINDS = ['session', 'host', 'bridge', 'cli'];
-/** Longest sender id kept; anything longer is malformed, not truncated. */
-export const SENDER_ID_CAP = 256;
-/**
- * Restore-side allowlist for one persisted sender: a well-formed value comes
- * back as a fresh object holding only kind, id and (when present) face; anything else is dropped whole (the row
- * itself survives — a bad sender never costs the debt record).
- * @param raw - the persisted value.
- * @returns the sender, or undefined when absent or malformed.
- */
-export function parseSender(raw) {
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
-        return undefined;
-    const { kind, id, face } = raw;
-    if (typeof kind !== 'string' || !SENDER_KINDS.includes(kind))
-        return undefined;
-    if (typeof id !== 'string' || id === '' || id.length > SENDER_ID_CAP)
-        return undefined;
-    if (face !== undefined && (typeof face !== 'string' || face === '' || face.length > SENDER_ID_CAP))
-        return undefined;
-    // `face` belongs to host senders only; on any other kind it is dropped, the sender kept.
-    return { kind: kind, id, ...(face !== undefined && kind === 'host' ? { face } : {}) };
-}
-/**
- * Spread helper for restore: `{ sender }` when the persisted value parses and
- * the row is not inbound (an inbound row's originator is its caller, never a
- * sender this host recorded), else nothing.
- */
-function withSender(raw, direction) {
-    if (direction === 'inbound')
-        return {};
-    const sender = parseSender(raw);
-    return sender === undefined ? {} : { sender };
-}
-/**
- * #114 S2: `{ auth }` when a persisted INBOUND row carries a record that
- * parses whole (parseAuthorization) and belongs to THIS row — its target is
- * the row's team and its receipt target the row's peer — else nothing: the
- * row survives as a pre-S2 row, never with a partially adopted or borrowed
- * record.
- */
-function withAuth(raw, entry, now) {
-    if (entry.direction !== 'inbound' && entry.direction !== 'outbound')
-        return {};
-    const auth = parseAuthorization(raw, now);
-    if (auth === undefined || auth.target !== entry.team)
-        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.
-    return auth.ingress === 'local' && entry.peer === 'local' ? { auth } : {};
-}
-/** Routing and answer facts copied unchanged between a row and its archive entry. */
-function routingOf(row) {
-    return {
-        ...(row.answeredAt !== undefined ? { answeredAt: row.answeredAt } : {}),
-        ...(row.forwarded === true ? { forwarded: true } : {}),
-        ...(row.peerKey !== undefined ? { peerKey: row.peerKey } : {}),
-        ...(row.peerHost !== undefined ? { peerHost: row.peerHost } : {}),
-        ...(row.deliveredTo !== undefined ? { deliveredTo: row.deliveredTo } : {}),
-    };
-}
-/** The facts of one outbound birth that fit the row (see {@link withRouting} for the same shape on restore). */
-function birthFacts(peer, birth) {
-    if (birth === undefined)
-        return {};
-    const fact = (v) => v !== undefined && v !== '' && v.length <= ROUTING_FACT_CAP;
-    const remote = peer !== 'local' && !peer.startsWith('local:');
-    return {
-        ...(!remote && birth.auth !== undefined && birth.auth.ingress === 'local' ? { auth: birth.auth } : {}),
-        ...(remote && birth.forwarded === true ? { forwarded: true } : {}),
-        ...(remote && fact(birth.peerKey) ? { peerKey: birth.peerKey } : {}),
-        ...(remote && fact(birth.peerHost) ? { peerHost: birth.peerHost } : {}),
-        ...(fact(birth.deliveredTo) ? { deliveredTo: birth.deliveredTo } : {}),
-    };
-}
-/** Bound on a persisted routing fact; anything longer (or empty, or not a string) is dropped on restore. */
-const ROUTING_FACT_CAP = 256;
-/**
- * #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).
- */
-function withRouting(entry) {
-    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:');
-    return {
-        ...(typeof entry.answeredAt === 'number' && Number.isFinite(entry.answeredAt) && entry.answeredAt >= 0 ? { answeredAt: entry.answeredAt } : {}),
-        ...(remoteOutbound && entry.forwarded === true ? { forwarded: true } : {}),
-        ...(remoteOutbound && fact(entry.peerKey) ? { peerKey: entry.peerKey } : {}),
-        ...(remoteOutbound && fact(entry.peerHost) ? { peerHost: entry.peerHost } : {}),
-        ...(fact(entry.deliveredTo) ? { deliveredTo: entry.deliveredTo } : {}),
-    };
-}
-/**
- * How one archived row ended (gh#31). The recorded field wins; legacy rows
- * fall back to the summary markers this ledger writes itself. The fallback
- * reads a receipt-settled row's summary, which is the peer's text, so it is
- * only as exact as the legacy data allows.
- * @param row - the archived record.
- * @returns the archive path that ended it.
- */
-export function archivedEndedBy(row) {
-    if (row.endedBy !== undefined)
-        return row.endedBy;
-    const summary = row.summary ?? '';
-    if (summary.startsWith('caller-cancelled'))
-        return 'cancelled';
-    if (summary.startsWith('caller-abandoned'))
-        return 'abandoned';
-    if (summary === ECHO_SUMMARY)
-        return 'echo';
-    return 'receipt';
-}
-/** Bound on ids and callers kept in settlement records; longer values are cut on write and refused on restore. */
-const SETTLEMENT_ID_CAP = 256;
-/** Bound of the refusal ring (design §4.4). */
-export const SETTLEMENT_REFUSAL_CAP = 64;
-const SETTLEMENT_REASONS = ['settler-off-chain', 'settler-unverified', 'on-behalf-mismatch', 'echo-off-chain'];
-const CHAIN_ROLES = ['target', 'target-member', 'host-face', 'compat', 'legacy', 'off-chain'];
-const PROOF_VALUES = ['origin-claim', 'claim-mismatch', 'legacy-window', 'unbound', 'cli-identity', 'in-process', 'none'];
-/** Restore-side allowlist for settledBy: whole or nothing. */
-function withSettledBy(raw) {
-    if (raw === null || typeof raw !== 'object')
-        return {};
-    const r = raw;
-    if (typeof r.caller !== 'string' || r.caller.length > SETTLEMENT_ID_CAP || typeof r.chain_role !== 'string' || !CHAIN_ROLES.includes(r.chain_role))
-        return {};
-    return { settledBy: { caller: r.caller, chain_role: r.chain_role } };
-}
-/** Restore-side allowlist for one refusal record: whole or nothing. */
-function parseRefusal(raw) {
-    if (raw === null || typeof raw !== 'object')
-        return undefined;
-    const r = raw;
-    const st = r.settler;
-    if (typeof r.taskId !== 'string' || r.taskId === '' || r.taskId.length > SETTLEMENT_ID_CAP || typeof r.at !== 'number' || !Number.isFinite(r.at))
-        return undefined;
-    if (typeof r.reason !== 'string' || !SETTLEMENT_REASONS.includes(r.reason) || typeof r.head !== 'string' || typeof r.enforced !== 'boolean')
-        return undefined;
-    if (st === null || typeof st !== 'object' || typeof st.caller !== 'string' || st.caller.length > SETTLEMENT_ID_CAP || typeof st.proof !== 'string' || !PROOF_VALUES.includes(st.proof) || (st.ingress !== 'wire' && st.ingress !== 'local'))
-        return undefined;
-    const count = r.count === undefined ? 1 : r.count;
-    if (typeof count !== 'number' || !Number.isInteger(count) || count < 1)
-        return undefined;
-    return { taskId: r.taskId, at: r.at, settler: { caller: st.caller, proof: st.proof, ingress: st.ingress }, reason: r.reason, head: r.head.slice(0, SUMMARY_CAP), enforced: r.enforced, count };
-}
+import { CALLER_ENDED_PREFIX, TASK_CAP, ARCHIVE_CAP, SUMMARY_CAP, TASK_STALE_TTL_MS, ARCHIVE_ENDS, ECHO_SUMMARY, ROUTING_FACT_CAP, SETTLEMENT_ID_CAP, SETTLEMENT_REFUSAL_CAP, withSender, withAuth, routingOf, birthFacts, withRouting, withSettledBy, parseRefusal, archivedEndedBy } from "./task-ledger-rows.js";
+export * from "./task-ledger-rows.js";
 /**
  * Bounded outbound-task ledger with whole-file persistence. Pure of any
  * routing knowledge: callers {@link track} a task when a route leaves it
@@ -235,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.
@@ -244,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();
     }
     /**
@@ -255,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
@@ -302,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();
@@ -326,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();
@@ -818,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;
@@ -837,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'
                             ? {
@@ -875,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?.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)
@@ -151,6 +154,7 @@ export function createInfoTools(deps) {
                     face: 'session',
                     node: {
                         id: agentId,
+                        ...(exec.agent !== undefined ? { name: nodeMetadataOf(exec.agent).name, ...(nodeMetadataOf(exec.agent).seatName !== undefined ? { seatName: nodeMetadataOf(exec.agent).seatName } : {}) } : {}),
                         ...(joined ? { team: `${config.team}/${id8(agentId)}` } : {}),
                         joined,
                         live,
@@ -158,6 +162,7 @@ export function createInfoTools(deps) {
                     teams: {
                         roster: [...teamMemberships.teamsOf(agentId)],
                         canvas: [...canvasTeamsOfSession(agentId)],
+                        canvasDetails,
                     },
                     allowlist: {
                         patterns,
@@ -209,6 +214,10 @@ export function createInfoTools(deps) {
                                     team: { type: 'string', required: true },
                                     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.' },
@@ -226,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}`),
                     }],
             },
@@ -299,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/a2a-client.d.ts

@@ -45,6 +45,7 @@ export interface A2aClientOptions {
     readonly originClaim?: (target: {
         readonly url: string;
         readonly method: string;
+        readonly body?: string;
     }) => Record<string, string>;
     /** Delayed-callback seam (HTTP timeouts). */
     readonly schedule: A2aSchedule;

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;