@nelsonlongxiang/dsh-open-a2a-net 0.6.42 → 0.7.0

package/lib/tools/info.js

@@ -7,7 +7,9 @@
  * a getter so the deps object can be built before the const is declared.
  * @module src/tools/info
  */
+import { reminderView } from "../reconciliation-state.js";
 import { defineTool } from '@deepseek-ai/dsh-tools';
+import { splitQualifiedMember } from "../canvas-member.js";
 import { peerDirectoryRows } from "../peer-directory.js";
 import { canvasMemberships, canvasOwners } from "../canvas-discovery.js";
 import { peerContentMeta } from "../node-self.js";
@@ -60,7 +62,7 @@ export function createInfoTools(deps) {
                 return id !== undefined && joinedSessions.has(id);
             });
         }
-        return joined.has(row.team) || (row.teams ?? []).some(team => joined.has(team));
+        return joined.has(row.team) || [...joined].some(ref => splitQualifiedMember(ref)?.handle === row.team && canvasStore.ownerKeyOf(ref) === card.publicKey) || (row.teams ?? []).some(team => joined.has(team));
     });
     /** Human duration for a ledger row: how long a task has been owed or took. */
     const describeAge = (ms) => {
@@ -163,6 +165,7 @@ export function createInfoTools(deps) {
                         roster: [...teamMemberships.teamsOf(agentId)],
                         canvas: [...canvasTeamsOfSession(agentId)],
                         canvasDetails,
+                        canvasMigration: (() => { const s = deps.canvasMigrationState(); return Object.fromEntries(['canvasLegacyBareMembers', 'epoch', 'legacyBareMembers', 'legacyInferredMembers', 'legacyInferenceResolutions', 'legacyCollisionWarnings', 'suspendedMembersCount'].map(key => [key, s[key]])); })(),
                     },
                     allowlist: {
                         patterns,
@@ -212,6 +215,7 @@ export function createInfoTools(deps) {
                                 additionalProperties: false,
                                 properties: {
                                     team: { type: 'string', required: true },
+                                    memberRef: { type: 'string', description: 'Owner-qualified session selector, bound to the verified publishing host key; not an independent authority.' },
                                     session: { type: 'string', required: true },
                                     name: { type: 'string', required: true },
                                     seatName: { type: 'string', description: 'Human-owned stable display label, never a route identity.' },
@@ -263,7 +267,8 @@ export function createInfoTools(deps) {
                                 const id = resolveLocal(ref);
                                 return id !== undefined && joinedSessions.has(id);
                             });
-                        return joined.has(row.team) || (row.teams ?? []).some(name => joined.has(name));
+                        const card = row.via ? cardCache.get(row.via)?.card : undefined;
+                        return joined.has(row.team) || [...joined].some(ref => splitQualifiedMember(ref)?.handle === row.team && canvasStore.ownerKeyOf(ref) === card?.publicKey) || (row.teams ?? []).some(name => joined.has(name));
                     });
                     const hiddenRemote = remoteBefore - teams.filter(row => row.local !== true).length;
                     // gh#39 (owner ruling: the listing ADVERTISES targets — an exposed
@@ -371,6 +376,10 @@ export function createInfoTools(deps) {
                                 },
                             },
                         },
+                        deliveryBookkeeping: { type: 'object', additionalProperties: false, required: true, properties: { orphaned: { type: 'number', required: true }, failures: { type: 'number', required: true }, lastError: { type: 'object', additionalProperties: false, properties: { at: { type: 'number', required: true }, code: { type: 'string', required: true } } } } },
+                        ledgerPersistence: { type: 'object', additionalProperties: false, required: true, properties: { ok: { type: 'boolean', required: true }, lastError: { type: 'object', additionalProperties: false, properties: { at: { type: 'number', required: true }, code: { type: 'string', required: true } } } } },
+                        nudgeEscalations: { type: 'object', additionalProperties: false, required: true, properties: { queued: { type: 'number', required: true }, unavailable: { type: 'number', required: true }, failed: { type: 'number', required: true }, lastAt: { type: 'number' }, lastError: { type: 'string' } } },
+                        reconciliationReminders: { type: 'object', additionalProperties: false, required: true, properties: { observed: { type: 'number', required: true }, repeatedlyUnreconciled: { type: 'number', required: true } } },
                         idempotency: {
                             type: 'object',
                             additionalProperties: false,
@@ -390,6 +399,9 @@ export function createInfoTools(deps) {
                 render: (_args, value) => [{
                         type: 'text',
                         text: [
+                            `Delivery bookkeeping: orphaned=${value.deliveryBookkeeping.orphaned} failures=${value.deliveryBookkeeping.failures}${value.deliveryBookkeeping.lastError ? " code=" + value.deliveryBookkeeping.lastError.code : ""}`,
+                            `Ledger persistence: ${value.ledgerPersistence.ok ? 'ok' : '!!! FAILED !!!'}${value.ledgerPersistence.lastError ? ' at=' + value.ledgerPersistence.lastError.at + ' code=' + value.ledgerPersistence.lastError.code : ''}`,
+                            `Nudge escalations: queued=${value.nudgeEscalations.queued} unavailable=${value.nudgeEscalations.unavailable} failed=${value.nudgeEscalations.failed}${value.nudgeEscalations.lastAt === undefined ? '' : ' lastAt=' + value.nudgeEscalations.lastAt}${value.nudgeEscalations.lastError ? ' code=' + value.nudgeEscalations.lastError : ''}`,
                             ...(value.inFlight.length === 0 ? [] : ['In flight:']),
                             ...value.inFlight.map((route) => `  → ${route.team} via ${route.peer === 'local' ? 'this host' : route.peer}`),
                             `Peers (${String(value.peers.length)}):`,
@@ -411,6 +423,10 @@ export function createInfoTools(deps) {
                         inFlight: [...inFlightRoutes.values()].map(route => ({ team: route.team, peer: route.peer, startedAt: route.startedAt })),
                         activity: recentActivity.slice(),
                         idempotency: idempotencyStore.stats(),
+                        deliveryBookkeeping: taskLedger.deliveryBookkeepingState(),
+                        ledgerPersistence: taskLedger.persistenceState(),
+                        nudgeEscalations: deps.nudgeEscalations?.() ?? { queued: 0, unavailable: 0, failed: 0 },
+                        reconciliationReminders: reminderSummary(),
                     };
                 }
                 // S5 scoped plane: the tracked fleet narrows to peers whose verified
@@ -451,11 +467,19 @@ export function createInfoTools(deps) {
                     peers,
                     inFlight: [...inFlightRoutes.values()].map(route => ({ team: route.team, peer: route.peer, startedAt: route.startedAt })).filter(inScope),
                     activity: recentActivity.filter(inScope),
+                    deliveryBookkeeping: taskLedger.deliveryBookkeepingState(),
+                    ledgerPersistence: taskLedger.persistenceState(),
+                    nudgeEscalations: deps.nudgeEscalations?.() ?? { queued: 0, unavailable: 0, failed: 0 },
                     idempotency: idempotencyStore.stats(),
+                    reconciliationReminders: reminderSummary(),
                 };
             },
         }));
     }
+    function reminderSummary() {
+        const seen = taskLedger.list().filter(row => row.status === 'pending').map(row => reminderView(taskLedger.reminderState(row.taskId)));
+        return { observed: seen.filter(v => v.reminderAttempts !== undefined).length, repeatedlyUnreconciled: seen.filter(v => v.repeatedlyUnreconciled).length };
+    }
     function registerTasks() {
         ctx.tools.register(defineTool({
             name: 'a2a_tasks',
@@ -488,6 +512,9 @@ export function createInfoTools(deps) {
                                     status: { type: 'string', required: true },
                                     deadAt: { type: 'number' },
                                     answeredAt: { type: 'number' },
+                                    receiptDelivery: { type: 'string', enum: ['receipt-undelivered'] },
+                                    consumed: { type: 'boolean' }, deliveryObservation: { type: 'string', enum: ['consumed', 'delivered-unconsumed'] },
+                                    reminderAttempts: { type: 'number' }, reminderDelivered: { type: 'number' }, reminderLastAt: { type: 'number' }, reminderNextAt: { type: 'number' }, reminderResult: { type: 'string' }, reminderDiagnostic: { type: 'string', enum: ['metadata-reset'] }, repeatedlyUnreconciled: { type: 'boolean' },
                                     direction: { type: 'string', enum: ['inbound', 'outbound'] },
                                     receiptExpected: { type: 'boolean' },
                                     forwarded: { type: 'boolean' },
@@ -516,6 +543,7 @@ export function createInfoTools(deps) {
                                     team: { type: 'string', required: true },
                                     startedAt: { type: 'number', required: true },
                                     resolvedAt: { type: 'number', required: true },
+                                    withdrawalResult: { type: 'string', enum: ['removed', 'claimed-steered', 'withdraw-failed-steered', 'no-agent'] },
                                     summary: { type: 'string' },
                                     brief: { type: 'string' },
                                     forwarded: { type: 'boolean' },
@@ -552,7 +580,7 @@ export function createInfoTools(deps) {
                                         ...settleable.map((task) => {
                                             const context = task.contextId === undefined || task.contextId === '' ? '' : `, follow-up context ${task.contextId}`;
                                             const brief = task.brief === undefined || task.brief === '' ? '' : ` — "${task.brief}"`;
-                                            return `  - ${task.taskId}${brief} → ${task.team} (via ${task.peer === 'local' ? 'this host' : task.peer}), waiting ${describeAge(Date.now() - task.startedAt)}${context}`;
+                                            return `  - ${task.taskId}${brief} → ${task.team} (via ${task.peer === 'local' ? 'this host' : task.peer}), waiting ${describeAge(Date.now() - task.startedAt)}${context}${task.receiptDelivery ? ' — ' + task.receiptDelivery : ''}${task.reminderAttempts === undefined ? '' : ` — reminders ${task.reminderDelivered ?? 0}/${task.reminderAttempts}, next ${task.reminderNextAt ?? 0}${task.repeatedlyUnreconciled ? ' (多次提醒未对账)' : ''}`}`;
                                         }),
                                         ...(staleCount > 0 ? [`Delivered conversationally without a formal receipt (${String(staleCount)}) — not debts; they auto-dead-letter at the stale TTL.`] : []),
                                     ];
@@ -566,7 +594,7 @@ export function createInfoTools(deps) {
                                 ...(value.archivedTotal > 0 ? [`Archived (${String(value.archivedTotal)}), most recent first:`] : []),
                                 ...value.archive.map((entry) => {
                                     const brief = entry.brief === undefined || entry.brief === '' ? '' : ` — "${entry.brief}"`;
-                                    return `  - ${entry.taskId}${brief} → ${entry.team}: after ${describeAge(entry.resolvedAt - entry.startedAt)}, ${entry.summary === undefined || entry.summary === '' ? 'resolved' : entry.summary}`;
+                                    return `  - ${entry.taskId}${brief} → ${entry.team}: after ${describeAge(entry.resolvedAt - entry.startedAt)}, ${entry.summary === undefined || entry.summary === '' ? 'resolved' : entry.summary}${entry.withdrawalResult ? `, withdrawal: ${entry.withdrawalResult}` : ''}`;
                                 }),
                                 ...(value.archivedTotal > value.archive.length ? [`  (+${String(value.archivedTotal - value.archive.length)} older not shown)`] : []),
                             ].join('\n'),
@@ -581,12 +609,14 @@ export function createInfoTools(deps) {
                     ok: true,
                     // Project the declared fields only: ledger rows also carry internal audit facts (the #114 auth record,
                     // #139 peerKey/peerHost) the output schema does not admit — spreading the row failed every call (0.6.32+).
-                    tasks: taskLedger.list().map(({ taskId, team, peer, startedAt, contextId, brief, status, deadAt, answeredAt, direction, receiptExpected, forwarded, deliveredTo, reason, sender }) => ({
-                        taskId, team, peer, startedAt, status,
+                    tasks: taskLedger.list().map(({ taskId, team, peer, startedAt, contextId, brief, status, deadAt, answeredAt, receiptDelivery, consumed, direction, receiptExpected, forwarded, deliveredTo, reason, sender }) => ({
+                        taskId, team, peer, startedAt, status, ...reminderView(taskLedger.reminderState(taskId)),
                         ...(contextId !== undefined ? { contextId } : {}),
                         ...(brief !== undefined ? { brief } : {}),
                         ...(deadAt !== undefined ? { deadAt } : {}),
                         ...(answeredAt !== undefined ? { answeredAt } : {}),
+                        ...(receiptDelivery ? { receiptDelivery } : {}),
+                        ...(consumed !== undefined ? { consumed, deliveryObservation: consumed ? 'consumed' : 'delivered-unconsumed' } : {}),
                         ...(direction !== undefined ? { direction } : {}),
                         ...(receiptExpected !== undefined ? { receiptExpected } : {}),
                         ...(forwarded !== undefined ? { forwarded } : {}),
@@ -594,7 +624,7 @@ export function createInfoTools(deps) {
                         ...(reason !== undefined ? { reason } : {}),
                         ...(sender !== undefined ? { sender } : {}),
                     })),
-                    archive: archiveAll.slice(0, 5).map(({ taskId, team, startedAt, resolvedAt, summary, brief, sender }) => ({ taskId, team, startedAt, resolvedAt, ...(summary !== undefined && summary !== '' ? { summary } : {}), ...(brief !== undefined ? { brief } : {}), ...(sender !== undefined ? { sender } : {}) })),
+                    archive: archiveAll.slice(0, 5).map(({ taskId, team, startedAt, resolvedAt, summary, brief, withdrawalResult, sender }) => ({ ...(withdrawalResult ? { withdrawalResult } : {}), taskId, team, startedAt, resolvedAt, ...(summary !== undefined && summary !== '' ? { summary } : {}), ...(brief !== undefined ? { brief } : {}), ...(sender !== undefined ? { sender } : {}) })),
                     archivedTotal: archiveAll.length,
                 };
             },

package/lib/types/a2a-client.d.ts

@@ -119,7 +119,7 @@ export declare class A2aClient {
      * @param callerSession - caller label overriding the node's label (the calling session's node label).
      * @returns the canonical route result (success or explicit failure).
      */
-    routeDirect(baseUrl: string, team: string, message: string, contextId?: string, signal?: AbortSignal, callerSession?: string, asyncMode?: boolean, taskIdFromCaller?: string, callbackAddress?: string, guard?: string): Promise<A2aRouteResult>;
+    routeDirect(baseUrl: string, team: string, message: string, contextId?: string, signal?: AbortSignal, callerSession?: string, asyncMode?: boolean, taskIdFromCaller?: string, callbackAddress?: string, guard?: string, cancelTaskId?: string): Promise<A2aRouteResult>;
     /**
      * Query a peer's `/a2a/query` outcome surface (W7 slice 2): read-only
      * lookup of one claimed task's settled outcome. The fingerprint is the

package/lib/types/admitted-bookkeeping.d.ts

@@ -0,0 +1,5 @@
+export declare const ADMITTED_BOOKKEEPING_NOTE = "\u5DF2\u9001\u8FBE\u3001\u63A5\u6536\u65B9\u8BB0\u8D26\u5931\u8D25\uFF0C\u8BF7\u5BF9\u8D26\uFF0C\u4E0D\u8981\u91CD\u6D3E\u3002Delivered, but receiver bookkeeping failed; reconcile the original task, do not redispatch.";
+export declare class AdmittedBookkeepingError extends Error {
+    readonly code: string;
+    constructor(error: unknown);
+}

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

@@ -0,0 +1,10 @@
+export interface QualifiedMember {
+    handle: string;
+    fingerprint: string;
+}
+/** CLI handles keep their existing home/deposit rules and are never parsed as session members. */
+export declare function splitQualifiedMember(ref: string): QualifiedMember | undefined;
+export declare function validMemberOwner(ref: string, key: string): boolean;
+export declare function qualifiedSessionMember(handle: string, key: string): string | undefined;
+export type MemberProvenance = 'local-id' | 'confirmed-local' | 'confirmed-remote' | 'unknown' | 'cli' | 'conflict';
+export declare function memberProvenance(ref: string, ownerKey: string | undefined, ownKey: string): MemberProvenance;

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

@@ -17,7 +17,21 @@
  * @module @nelsonlongxiang/dsh-open-a2a-net/canvas-store
  */
 /** On-disk shape: ordered team entries, each an ordered member id list. */
+export interface SuspendedCanvasMember {
+    readonly team: string;
+    readonly member: string;
+    readonly localSessionId: string;
+    readonly reason: 'leave' | 'archive' | 'remove';
+    readonly at: string;
+    readonly token: string;
+}
+/** A bare session handle is not a CLI identity or a qualified owner selector. */
+export declare function legacyBareMember(id: string): boolean;
 export interface CanvasSnapshot {
+    readonly formatVersion?: number;
+    readonly revision?: number;
+    readonly memberOwners?: Readonly<Record<string, string>>;
+    readonly suspendedMembers?: readonly SuspendedCanvasMember[];
     readonly teams: ReadonlyArray<{
         readonly name: string;
         readonly members: readonly string[];
@@ -52,16 +66,28 @@ export declare function validRemoteMemberRef(id: string): boolean;
  * registry knowledge: callers validate join state and resolve members.
  */
 export declare class CanvasStore {
+    private readonly options;
     /** Team entries in creation order; members in add order (routing priority). */
     private teams;
     private cliHome;
     private cliHomeCleared;
+    private suspended;
+    private revision;
+    private committed;
+    private memberOwners;
+    private disk;
+    private readOnlyReason;
+    private lastWriteError;
+    private failedSuspension;
     private readonly path;
     private readonly listeners;
     /**
      * @param path - the snapshot file; an empty path keeps the store in memory.
      */
-    constructor(path: string);
+    constructor(path: string, options?: {
+        legacyBareMembers?: boolean;
+        ownPublicKey?: string;
+    });
     /**
      * Observe changes: the listener runs after every write that changed the
      * store (never on restore). A throwing listener cannot break the write.
@@ -73,13 +99,41 @@ export declare class CanvasStore {
     private restore;
     /** Persist the current snapshot (no-op without a path), then tell the listeners. */
     private persist;
+    private serialize;
     private write;
+    private replaceFile;
+    private lockInfo;
     /** Every team name, in creation order. */
     list(): readonly string[];
     /** Whether the named team exists. */
     hasTeam(name: string): boolean;
     /** The named team's member ids in routing-priority order (a copy). */
     membersOf(name: string): readonly string[];
+    /** Inspection only: never use raw rows for routing, authorization or counts. */
+    rawMembersOf(name: string): readonly string[];
+    isSuspended(name: string, member: string): boolean;
+    suspensionOf(name: string, member: string): readonly SuspendedCanvasMember[];
+    state(): {
+        revision: number;
+        suspendedMembers: readonly SuspendedCanvasMember[];
+        error?: string;
+        lock?: unknown;
+        directoryFsync: string;
+    };
+    ownerKeyOf(member: string): string | undefined;
+    private ownerConflict;
+    /** Owner control only: CAS the complete slot and preserve suspension plus routing priority. */
+    confirmMember(team: string, member: string, replacement: string, ownerKey: string | undefined, revision: unknown, expectedOwner: unknown): {
+        ok: boolean;
+        error?: string;
+    };
+    /** Durably revoke canvas consent BEFORE join/agent/roster state is removed. */
+    revokeLocal(id: string, ownQualified: string | undefined, inferredBare: string | undefined, reason: SuspendedCanvasMember['reason'], team?: string): boolean;
+    /** Owner-only CAS. The caller supplies the exact slot and the complete current suspension records. */
+    regulateSuspended(action: 'restore' | 'delete', team: string, member: string, revision: unknown, expected: unknown): {
+        ok: boolean;
+        error?: string;
+    };
     /** Frozen, operator-linked CLI home; undefined means unknown or ambiguous. */
     cliHomeOf(handle: string): string | undefined;
     pinnedCliHomes(): ReadonlyArray<readonly [string, string]>;
@@ -114,6 +168,7 @@ export declare class CanvasStore {
      */
     addMember(name: string, id: string, home?: string, options?: {
         replaceHome?: boolean;
+        ownerKey?: string;
     }): boolean;
     /**
      * Remove one member from one team (a no-op when absent).

package/lib/types/config.d.ts

@@ -77,6 +77,8 @@ export interface Config {
      * closed, it signs and accepts the audience-bound form only.
      */
     readonly originClaimUnboundWindow: boolean;
+    /** #335: preserve unsuspended legacy bare member inference until the owner closes the window. */
+    readonly canvasLegacyBareMembers: boolean;
     /**
      * Extra origins this host answers to as an OriginClaim audience, beyond
      * its card URL and the address a request arrives on (port-mapped or

package/lib/types/faces/admin.d.ts

@@ -21,6 +21,7 @@ import type { OriginClaimTarget } from '../origin-claim.ts';
 export type RemoteRowsCache = {
     at: number;
     rows: {
+        memberRef?: string;
         team: string;
         name: string;
         origin?: string;
@@ -62,6 +63,14 @@ export interface AdminFaceDeps extends Pick<CanvasNotifyDeps, 'verifyOriginClaim
     readonly cliDeposits: CliDepositStore;
     readonly groupStore: GroupStore;
     readonly canvasStore: CanvasStore;
+    readonly canvasMemberForWrite: (ref: string, peer?: unknown) => Promise<{
+        ok: true;
+        member: string;
+        ownerKey?: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
     readonly cliHomeForAdd: (handle: string, requested?: unknown) => Promise<CliHomeDecision>;
     readonly cliHomeOptions: (handle: string) => Promise<{
         homes: string[];
@@ -70,6 +79,8 @@ export interface AdminFaceDeps extends Pick<CanvasNotifyDeps, 'verifyOriginClaim
     }>;
     readonly layoutStore: LayoutStore;
     readonly taskLedger: TaskLedger;
+    readonly reminderDiagnostics?: () => unknown;
+    readonly nudgeEscalations?: () => import('../nudge-observability.ts').NudgeEscalations;
     readonly enforceRefused?: {
         reason: string;
         blockers: readonly string[];
@@ -126,6 +137,8 @@ export interface AdminFaceDeps extends Pick<CanvasNotifyDeps, 'verifyOriginClaim
     readonly sessionTeamOf: (agent: Agent) => string;
     /** gh#131: the `<zone>/<id8>` handle a canvas may hold for this local session, if it reads as this session. */
     readonly ownCanvasHandleOf: (id: string) => string | undefined;
+    readonly revokeCanvasMember: (id: string, reason: 'leave' | 'archive' | 'remove', name?: string) => boolean;
+    readonly canvasMigrationState: () => Record<string, unknown>;
     /** gh#131: the local session a remote-shaped member ref reads as, if unambiguous. */
     readonly localSessionOfHandle: (ref: string) => string | undefined;
     /** gh#152: the session's canvas teams read through the local lens — a handle-stored membership of this session counts. */
@@ -150,6 +163,14 @@ export interface AdminFaceDeps extends Pick<CanvasNotifyDeps, 'verifyOriginClaim
         count: number;
         lastAt: number;
     }>;
+    readonly claimRejectsInboundCount: number;
+    readonly claimRejectsRecent: ReadonlyArray<{
+        caller: string;
+        callerUrl: string;
+        reason: string;
+        count: number;
+        lastAt: number;
+    }>;
     readonly ownCardUrl: string;
     /** #282 S2: this host's canvas owner fingerprint. */
     readonly ownCanvasFingerprint: string;

package/lib/types/faces/files.d.ts

@@ -26,7 +26,7 @@ export interface FileFaceDeps {
     readonly ctx: Context;
     readonly config: Pick<Config, 'apiKey' | 'team'>;
     readonly blobStore: BlobStore;
-    readonly canvasStore: Pick<CanvasStore, 'membersOf'>;
+    readonly canvasStore: Pick<CanvasStore, 'membersOf'> & Partial<Pick<CanvasStore, 'ownerKeyOf'>>;
     readonly verifyOriginClaim: (req: IncomingMessage, options?: {
         readonly cli?: boolean;
     }) => Promise<OriginClaimResult>;

package/lib/types/faces/wire.d.ts

@@ -22,6 +22,7 @@ import type { IdempotencyStore } from '../idempotency-store.ts';
 import type { JoinedSessions } from '../joined-store.ts';
 import { type TaskLedger } from '../task-ledger.ts';
 import { type Admission, type RemoteCliProof, type SettlementRefusal, type Settler } from '../task-auth.ts';
+import { type OriginClaimVerdict } from '../origin-claim.ts';
 import type { Config } from '../index.ts';
 /**
  * #139 (design §4.4): add `settlement: {status:'refused', reason, task_id}`
@@ -46,6 +47,7 @@ export type ColdWake = {
 export type RouteOutcome = {
     ok: true;
     reply: string;
+    receiverBookkeeping?: 'failed';
     status?: string;
     bridge?: 'native-teams';
     placeholder?: boolean;
@@ -105,18 +107,7 @@ export type NativeRoundOutcome = {
     readonly aborted?: boolean;
 };
 /** What verifyOriginClaim answers (see index.ts; reason widens to string here — the faces only interpolate it). */
-export type OriginClaimResult = {
-    ok: true;
-    caller: string;
-    callerUrl: string;
-    card: A2aPeerCard;
-    bound: boolean;
-    cli?: true;
-    bodyBound?: true;
-} | {
-    ok: false;
-    reason: string;
-};
+export type OriginClaimResult = OriginClaimVerdict;
 /** The closure captures the wire faces read (grows with each extracted face). */
 export interface WireDeps {
     readonly ctx: Context;
@@ -124,6 +115,14 @@ export interface WireDeps {
     readonly config: Config;
     readonly cliDeposits: CliDepositStore;
     readonly canvasStore: CanvasStore;
+    readonly canvasMemberForWrite: (ref: string, peer?: unknown, editorCard?: A2aPeerCard) => Promise<{
+        ok: true;
+        member: string;
+        ownerKey?: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
     readonly canvasNameReserved: (name: string) => boolean;
     readonly sessionNodes: Map<string, Agent>;
     readonly joinedSessions: JoinedSessions;
@@ -143,6 +142,9 @@ export interface WireDeps {
     readonly forwardReceiptBasis: (taskId: string, caller: string, cliHandle: string, claim: Extract<OriginClaimResult, {
         ok: true;
     }>) => string | undefined;
+    readonly receiptReplayAllowed: (message: string, caller: string, team: string, claim: Extract<OriginClaimResult, {
+        ok: true;
+    }>) => boolean;
     readonly callerLinkedToThisHost: (caller: string, callerUrl: string, callerCard: A2aPeerCard | undefined) => boolean;
     /** This host's own card URL (read when a request lands; set once the web server settles). */
     readonly ownCardUrl: string;
@@ -152,7 +154,7 @@ export interface WireDeps {
     readonly peerKeyAdmits: (req: IncomingMessage, rawBody?: Uint8Array) => Promise<boolean>;
     readonly a2aCallerRefusal: (caller: string, targetTeam?: string) => string | undefined;
     /** #114 S2: the same decision with the rule and basis that admitted the caller. */
-    readonly a2aCallerAdmission: (caller: string, targetTeam?: string, cliProof?: RemoteCliProof) => Admission;
+    readonly a2aCallerAdmission: (caller: string, targetTeam?: string, cliProof?: RemoteCliProof, signerKey?: string) => Admission;
     /** #114 S2: this host's allowlist version right now (design §2.3). */
     readonly allowlistVersionNow: () => string;
     /** #114 S6: record the version if it moved and re-judge affected tasks (observe only). */
@@ -192,6 +194,11 @@ export interface WireDeps {
     readonly sessionTeamOf: (agent: Agent) => string;
     /** gh#131: the local session one of this host's own `<zone>/<id8>` handles names, if exactly one. */
     readonly localSessionOfHandle: (ref: string) => string | undefined;
+    readonly cancelQueuedTask: (taskId: string, message: string, sender: string, original?: import('../task-ledger.ts').TaskRecord) => Promise<{
+        removed: boolean;
+        steered: boolean;
+    }>;
+    readonly followupRelay: (agent: Agent, text: string, sender?: string, localFrom?: string, taskId?: string, callerKey?: string, taskExpected?: boolean) => void;
     readonly steerRelay: (agent: Agent, text: string, sender?: string) => void;
     readonly fromClause: (from: string) => string;
     readonly sanitizeFromClause: (from: string) => string;
@@ -210,7 +217,7 @@ export interface WireDeps {
     readonly nativeTeamsRound: (prepared: Extract<NativePrepared, {
         ok: true;
     }>, team: string, caller: string, message: string, taskId: string | undefined, proofClause: string, external?: AbortSignal, proofHeader?: (team: string, taskId: string, from: string, proofClause: string) => string) => Promise<NativeRoundOutcome>;
-    readonly routeIntoAgent: (team: string, message: string, caller: string, taskId?: string, proofClause?: string, directHeader?: (from: string) => string, localFrom?: string, onSteered?: (target: Agent, floor: number) => void) => Promise<RouteOutcome>;
+    readonly routeIntoAgent: (team: string, message: string, caller: string, taskId?: string, proofClause?: string, directHeader?: (from: string) => string, localFrom?: string, onSteered?: (target: Agent, floor: number) => void, callerKey?: string) => Promise<RouteOutcome>;
 }
 /**
  * #187: what a verified claim may vouch for at settlement. The signing key always (the card was

package/lib/types/followup-delivery.d.ts

@@ -0,0 +1,25 @@
+/** #356 sourced follow-up admission after the existing A2A authorization/queue gates. */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { MessageId } from '@deepseek-ai/dsh-llm';
+import type { TaskLedger } from './task-ledger.ts';
+export interface FollowupDeps {
+    ledger: TaskLedger;
+    taint: (target: Agent, localFrom?: string) => void;
+    warn: (code: string) => void;
+}
+export declare class FollowupDelivery {
+    private readonly d;
+    constructor(d: FollowupDeps);
+    deliver(agent: Agent, text: string, sender?: string, localFrom?: string, taskId?: string, callerKey?: string, taskExpected?: boolean): void;
+    /** Only called after the existing cancel authorization has identified the original task. */
+    withdraw(taskId: string, controller: {
+        updateQueue: (request: {
+            sessionId: Agent['id'];
+            itemId: MessageId;
+            action: {
+                kind: 'remove';
+            };
+        }) => Promise<unknown>;
+    } | undefined, resolve: (id: string) => Agent | undefined): Promise<'removed' | 'claimed' | 'legacy'>;
+    claimed(agent: Agent, messageId: string): void;
+}

package/lib/types/idempotency-store.d.ts

@@ -142,6 +142,8 @@ export declare class IdempotencyStore {
      * Unknown or already-settled ids answer `false`. Never throws.
      * @returns whether the outcome was recorded.
      */
+    /** Release only an unchanged, uncompleted receipt attempt whose settlement did not commit. */
+    releaseUncompleted(taskId: string, fingerprint: string): void;
     recordOutcome(taskId: string, outcome: TaskOutcome, settledAt?: number): boolean;
     /**
      * Read-only outcome lookup for the `/a2a/query` surface (W7 slice 2).

package/lib/types/inbound-verification.d.ts

@@ -0,0 +1,14 @@
+/** Bounded completion gate for inbound request verification. */
+import type { IncomingMessage } from 'node:http';
+import type { Admission } from './task-auth.ts';
+import { type OriginClaimVerdict } from './origin-claim.ts';
+export declare const WIRE_ERROR_INBOUND_VERIFICATION = -32011;
+export declare function hasOriginClaimFields(req: Pick<IncomingMessage, 'headers'>): boolean;
+export declare function completeInboundVerification(work: () => Promise<OriginClaimVerdict>, timeoutMs?: number): Promise<OriginClaimVerdict>;
+export declare function verifiedInboundAdmission(claim: OriginClaimVerdict, present: boolean, requireBound: boolean, admit: (signerKey: string | undefined) => Admission): {
+    ok: true;
+    admission: Admission;
+} | {
+    ok: false;
+    reason: string;
+};

package/lib/types/index.d.ts

@@ -30,6 +30,11 @@ declare module '@deepseek-ai/dsh-llm' {
              * ui-chat's relay context body renders "来自 X" + the full text from
              * this field; without it the row falls back to an opaque body. */
             senderSessionId?: string;
+            /** Audited A2A task identity and clean same-host lineage, never a human principal. */
+            taskId?: string;
+            localSender?: string;
+            /** Host-built node reminder only; never copied from an inbound peer source. */
+            nodeReminder?: true;
         };
     }
 }

package/lib/types/nudge-observability.d.ts

@@ -0,0 +1,17 @@
+/** Observation only; no scheduling, delivery or ledger authority. */
+export interface NudgeEscalations {
+    queued: number;
+    unavailable: number;
+    failed: number;
+    lastAt?: number;
+    lastError?: string;
+}
+export declare function safeObservationCode(error: unknown, fallback: string): string;
+export declare class NudgeObservability {
+    private readonly warn;
+    private readonly now;
+    private value;
+    constructor(warn: (message: string) => void, now?: () => number);
+    snapshot(): NudgeEscalations;
+    note(result: 'queued' | 'unavailable' | 'failed', team: string, ref: string, error?: unknown): void;
+}

package/lib/types/origin-claim.d.ts

@@ -28,6 +28,8 @@ import type { CardCacheEntry } from './runtime.ts';
 import type { A2aPeerCard } from './types.ts';
 /** ts skew tolerance (protocol constant, §7). */
 export declare const ORIGIN_CLAIM_SKEW_MS: number;
+/** Local verification work budget, including response body reads. */
+export declare const ORIGIN_CLAIM_VERIFY_MS = 5000;
 /** Domain tag of the bound form: a v1 signature can never verify as v2. */
 export declare const ORIGIN_CLAIM_BOUND_TAG = "a2a-origin-claim/2";
 export declare const ORIGIN_CLAIM_BODY_TAG = "a2a-origin-claim/3";
@@ -39,7 +41,7 @@ export interface OriginClaimTarget {
     readonly method: string;
     readonly body?: string | Uint8Array;
 }
-export type OriginClaimRefusal = 'absent' | 'bad-caller-shape' | 'bad-ts' | 'no-card' | 'bad-sig' | 'not-derivable' | 'wrong-audience' | 'unbound-closed' | 'body-mismatch';
+export type OriginClaimRefusal = 'absent' | 'bad-caller-shape' | 'bad-ts' | 'no-card' | 'bad-sig' | 'not-derivable' | 'wrong-audience' | 'unbound-closed' | 'body-mismatch' | 'verification-timeout';
 /** Only the canonical origin root can claim that origin's identity. */
 export declare function isRootOriginUrl(value: string): boolean;
 /**
@@ -127,6 +129,10 @@ export declare function verifyOriginClaim(req: IncomingMessage, d: {
     /** A loopback arrival is an audience of its own (default); off when originClaimUrl declares a tunnel or proxy. */
     readonly loopbackArrival?: boolean;
     readonly now: number;
+    /** Internal deterministic test seam; production uses ORIGIN_CLAIM_VERIFY_MS. */
+    readonly timeoutMs?: number;
+    /** Request admission requires a current card read, not a discovery cache assertion. */
+    readonly freshCard?: boolean;
     /** Exact received bytes, supplied by the bounded body reader. Missing bytes cannot verify Sig3. */
     readonly rawBody?: Uint8Array;
     /** On the faces that admit CLI identities: the deposit a claim URL names. */

package/lib/types/outbound-scope.d.ts

@@ -7,6 +7,7 @@ export interface OutboundScopeRecords {
     canvasNames(): readonly string[];
     canvasMembers(name: string): readonly string[];
     canvasTeam(name: string): string;
+    memberHandle?(ref: string): string;
     peerOrgs(): Iterable<readonly {
         team?: unknown;
         members?: unknown;

package/lib/types/peer-store.d.ts

@@ -165,9 +165,13 @@ export declare class PeerStore {
      * re-seeded from config on every boot, and scores rebuild on contact.
      */
     private dirty;
+    private closed;
     private writeChain;
     private pendingTimer;
     private persist;
+    private writePending;
+    /** Final teardown: drain once, then late peer responses cannot recreate this home. */
+    close(): Promise<void>;
     /**
      * Await the last scheduled write (tests and teardown). Resolves when the
      * debounced write chain has settled with the current in-memory state.

package/lib/types/queue-guard.d.ts

@@ -17,6 +17,13 @@ export declare const WIRE_ERROR_QUEUE_FULL = -32009;
 export declare const DEFAULT_TARGET_QUEUE_CAP = 3;
 /** The ledger fields the count reads. */
 export interface QueueRow {
+    readonly taskId?: string;
+    readonly auth?: {
+        readonly caller: string;
+    };
+    readonly sender?: {
+        readonly id: string;
+    };
     readonly team: string;
     readonly peer: string;
     readonly status: string;
@@ -30,6 +37,6 @@ export declare function queuedFor(rows: readonly QueueRow[], team: string): numb
 /** The refusal text when `team`'s queue is full, else undefined. `cap <= 0` disables the guard. */
 export declare function queueFullRefusal(rows: readonly QueueRow[], team: string, message: string, cap: number, mailbox: boolean, ownTask: (taskId: string) => boolean): string | undefined;
 /** #282 S1: the one next step for a full target queue. */
-export declare const QUEUE_FULL_NEXT = "wait for a receipt from the target (a2a-net inbox / a2a_tasks), then send again with a new task id; do not resend in a loop";
+export declare const QUEUE_FULL_NEXT = "wait for a receipt from the target after it reconciles its outstanding tasks (a2a-net inbox / a2a_tasks), then send again with a new task id; do not resend in a loop";
 /** Wire-face adapter in the flood guard's shape: a refused fresh key is FAILED, not stranded pending. */
-export declare function createQueueGuard(rows: () => readonly QueueRow[], cap: () => number, ownTask: (taskId: string) => boolean, outcomes: Pick<IdempotencyStore, 'recordOutcome'>, recordActivity: (dir: 'in' | 'out', team: string, peer: string, ok: boolean) => void): (caller: string, message: string, team: string, taskId: string, mailbox: boolean, res: ServerResponse) => boolean;
+export declare function createQueueGuard(rows: () => readonly QueueRow[], cap: () => number, ownTask: (taskId: string) => boolean, outcomes: Pick<IdempotencyStore, 'recordOutcome'>, recordActivity: (dir: 'in' | 'out', team: string, peer: string, ok: boolean) => void, reminder?: (taskId: string) => Record<string, unknown>): (caller: string, message: string, team: string, taskId: string, mailbox: boolean, res: ServerResponse) => boolean;

package/lib/types/receipt-ladder.d.ts

@@ -11,6 +11,8 @@
 export interface ReceiptLadderDeps {
     /** Try delivering the receipt text to one routable team. */
     deliver: (team: string) => Promise<unknown>;
+    /** Transient caller failures never enter the receipt-bearing owner tier. */
+    transient?: (error: unknown) => boolean;
     /** This host's process/team mailbox (tier two). */
     ownerTeam: string;
     /** Observability hook: `stage` distinguishes `to <team>` / `to owner <team>` / `both lanes`. */