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

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

@@ -0,0 +1,22 @@
+/** Host-owned bounded retry policy; never changes the receipt text. */
+import type { Context } from '@deepseek-ai/cordis';
+export declare function receiptRetryWait(ctx: Pick<Context, 'effect'>, ms: number): Promise<boolean>;
+export declare const RECEIPT_RETRYABLE: unique symbol;
+export declare const RECEIPT_RETRY_DELAYS_MS: readonly [1000, 2000, 4000, 8000, 16000, 30000];
+export declare class ReceiptDeliveryError extends Error {
+    readonly transient: boolean;
+    constructor(message: string, transient: boolean);
+}
+export declare function transientReceiptFailure(error: unknown): boolean;
+export declare function receiptFailure(result: {
+    error: string;
+    code?: number;
+    [RECEIPT_RETRYABLE]?: true;
+}): ReceiptDeliveryError;
+export declare function retryReceiptDelivery(d: {
+    attempt: () => Promise<void>;
+    notify: () => Promise<void>;
+    pending: () => boolean;
+    wait: (ms: number) => Promise<boolean>;
+    log: (error: unknown) => void;
+}, delays?: readonly number[]): Promise<void>;

package/lib/types/reconciliation-reminders.d.ts

@@ -0,0 +1,41 @@
+import type { TaskLedger, TaskRecord } from './task-ledger.ts';
+export interface ReminderAgent {
+    id: unknown;
+    status: string;
+}
+export interface ReminderDeps {
+    ledger: TaskLedger;
+    agents: () => readonly ReminderAgent[];
+    resolve: (row: TaskRecord) => ReminderAgent | undefined;
+    sender: (row: TaskRecord) => ReminderAgent | undefined;
+    followup: (agent: ReminderAgent, text: string) => void;
+    now?: () => number;
+    warn: (code: string) => void;
+}
+export declare class ReconciliationReminders {
+    private readonly d;
+    private stopped;
+    private active;
+    private failedUntil;
+    private nudgeAt;
+    readonly diagnostics: {
+        lastCheckedAt: number;
+        unresolved: number;
+        lastError?: {
+            at: number;
+            code: string;
+        };
+    };
+    constructor(d: ReminderDeps);
+    stop(): void;
+    /** Shared session gate with the existing unread nudge; no budget/consumption changes. */
+    nudgeAllowed(id: string): boolean;
+    noteNudge(id: string): void;
+    private now;
+    private idle;
+    private throttled;
+    scan(): void;
+    private report;
+    private remind;
+    private notify;
+}

package/lib/types/reconciliation-state.d.ts

@@ -0,0 +1,32 @@
+/** #351 reminder observations only: never a task lifecycle or acknowledgement. */
+export declare const REMINDER_SCAN_MS = 60000;
+export declare const REMINDER_MIN_MS = 120000;
+export declare const REMINDER_LONG_MS: number;
+export declare const REMINDER_WARNING_MS: number;
+export interface ReminderState {
+    version: 1;
+    targetId: string;
+    attempts: number;
+    deliveredCount: number;
+    lastAttemptAt: number;
+    nextAt: number;
+    requestId: string;
+    lastResult: 'reserved' | 'delivered' | 'failed' | 'unknown';
+    lastDeliveredAt?: number;
+    noticeAttemptedAt?: number;
+    notifiedAt?: number;
+    escalationAt?: number;
+    diagnostic?: 'metadata-reset';
+}
+export declare function parseReminder(raw: unknown): ReminderState | undefined;
+export declare function nextReminderDelay(attempts: number): number;
+export interface ReminderView {
+    reminderAttempts: number;
+    reminderDelivered: number;
+    reminderLastAt: number;
+    reminderNextAt: number;
+    repeatedlyUnreconciled: boolean;
+    reminderResult: string;
+    reminderDiagnostic?: 'metadata-reset';
+}
+export declare function reminderView(state: ReminderState | undefined, now?: number): Partial<ReminderView>;

package/lib/types/session-transcript.d.ts

@@ -26,7 +26,12 @@ export declare function scanZstdFrames(buffer: Buffer): FrameRange[];
  * artifacts are split into frames and decoded frame by frame (node's public
  * decoder is single-frame).
  */
-export declare function decodeSessionLog(buffer: Buffer): string;
+type BoundedZstdDecoder = (input: Uint8Array, options: {
+    maxOutputLength: number;
+}) => Buffer;
+/** Codec seam for tests; budgets may only tighten the shipped hard caps. */
+export declare function createSessionLogDecoder(decoder?: BoundedZstdDecoder | undefined, outputCap?: number): (buffer: Buffer) => string;
+export declare const decodeSessionLog: (buffer: Buffer) => string;
 /**
  * Extract the last `limit` human-visible turns from a decoded session log.
  * User lines come from user/message data.content[].text; assistant lines from

package/lib/types/task-auth.d.ts

@@ -43,10 +43,17 @@ export interface AdmissionRecords {
         readonly teams: readonly string[];
     }[];
     joined(): readonly string[];
+    /** Caller-only proof projection; targets still use the complete local registry. */
+    callerJoined?(): readonly string[];
+    callerMemberships?(): readonly {
+        readonly session: string;
+        readonly teams: readonly string[];
+    }[];
     canvasNames(): readonly string[];
     /** Canvas names the session sits in. */
     canvasTeamsOf(sessionId: string): readonly string[];
     canvasMembersOf(name: string): readonly string[];
+    callerCanvasMembersOf?(name: string): readonly string[];
     canvasRemoteMembersOf(name: string): readonly string[];
     /** The canvasOrg lists of the warm peer-card cache. */
     peerOrgs(): Iterable<readonly PeerOrgEntry[]>;

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

@@ -0,0 +1,17 @@
+export interface TaskDelivery {
+    version: 1;
+    taskId: string;
+    messageId: string;
+    sessionId: string;
+    fingerprint: string;
+    callerKey?: string;
+    /** Distinguishes task births from receipt-only or synchronous receiptless occurrences. */
+    taskExpected?: true;
+    createdAt: number;
+    state: 'reserved' | 'enqueued' | 'claimed' | 'cancelled' | 'failed';
+}
+export declare const TASK_DELIVERY_CAP = 512;
+/** Keep completed/cancelled occurrence identities through the server idempotency window. */
+export declare const TASK_DELIVERY_RETENTION_MS: number;
+export declare function deliveryFingerprint(sessionId: string, text: string, sender?: string, localFrom?: string): string;
+export declare function parseTaskDelivery(raw: unknown): TaskDelivery | undefined;

package/lib/types/task-ledger-persistence.d.ts

@@ -0,0 +1,3 @@
+/** Brief AV/indexer contention must not turn into an unbounded synchronous stall. */
+export declare const LEDGER_RENAME_RETRY_MS: readonly [2, 4];
+export declare function writeTaskLedger(path: string, bytes: string): void;

package/lib/types/task-ledger-rows.d.ts

@@ -105,6 +105,9 @@ export declare function withAuth(raw: unknown, entry: {
 export declare function routingOf(row: Pick<TaskRecord, 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'answeredAt' | 'receiverMembers'>): Pick<TaskRecord, 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'answeredAt' | 'receiverMembers'>;
 /** #139: what an outbound row is born with besides its sender. */
 export interface OutboundBirth {
+    readonly consumed?: boolean;
+    /** Exact receiver selected at local delivery, never inferred from a later canvas roster. */
+    readonly receiverSessionId?: string;
     readonly forwarded?: true;
     /** Local-candidate admission, or a forwarded online CLI's verified wire admission. */
     readonly auth?: TaskAuthorization;
@@ -115,7 +118,7 @@ export interface OutboundBirth {
     readonly receiverMembers?: readonly string[];
 }
 /** The facts of one outbound birth that fit the row (see {@link withRouting} for the same shape on restore). */
-export declare function birthFacts(peer: string, birth: OutboundBirth | undefined, team?: string, sender?: Sender, now?: number, warn?: (message: string) => void): Pick<TaskRecord, 'auth' | 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'receiverMembers'>;
+export declare function birthFacts(peer: string, birth: OutboundBirth | undefined, team?: string, sender?: Sender, now?: number, warn?: (message: string) => void): Pick<TaskRecord, 'auth' | 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'receiverMembers' | 'receiverSessionId' | 'consumed'>;
 /** Bound on a persisted routing fact; anything longer (or empty, or not a string) is dropped on restore. */
 export declare const ROUTING_FACT_CAP = 256;
 export declare function parseReceiverMembers(value: unknown, warn?: (message: string) => void): readonly string[] | undefined;
@@ -125,9 +128,14 @@ export declare function parseReceiverMembers(value: unknown, warn?: (message: st
  * a remote outbound row; anything else is dropped (the row survives as one
  * born before the fields, judged by current membership and origin).
  */
-export declare function withRouting(entry: Record<string, unknown>, warn?: (message: string) => void): Pick<TaskRecord, 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'answeredAt' | 'receiverMembers'>;
+export declare function withRouting(entry: Record<string, unknown>, warn?: (message: string) => void): Pick<TaskRecord, 'peerKey' | 'peerHost' | 'deliveredTo' | 'forwarded' | 'answeredAt' | 'receiverMembers' | 'receiptDelivery'>;
 /** One tracked outbound task still in the owed book (unsettled). */
 export interface TaskRecord {
+    /** Local work answered, but successful receipt delivery is not confirmed; never a settlement. */
+    receiptDelivery?: 'receipt-undelivered';
+    /** Observation from exact inbox claim or peer response, never an acknowledgement. */
+    consumed?: boolean;
+    readonly receiverSessionId?: string;
     readonly taskId: string;
     readonly team: string;
     readonly peer: string;
@@ -184,8 +192,13 @@ export interface TaskRecord {
      */
     reason?: DeadReason;
 }
+export declare const WITHDRAWAL_RESULTS: readonly ["removed", "claimed-steered", "withdraw-failed-steered", "no-agent"];
+export type WithdrawalResult = typeof WITHDRAWAL_RESULTS[number];
+export declare function isWithdrawalResult(value: unknown): value is WithdrawalResult;
 /** One settled task kept for audit, with its receipt-correlated outcome. */
 export interface ArchivedRecord {
+    /** Cancellation notification observation; independent of the terminal task outcome. */
+    readonly withdrawalResult?: WithdrawalResult;
     readonly taskId: string;
     readonly team: string;
     readonly peer: string;
@@ -298,6 +311,10 @@ export interface ReceiptResolvedInfo {
 }
 /** The persisted ledger document: the owed book plus its settled archive. */
 export interface TaskLedgerSnapshot {
+    readonly taskDeliveryRestoreError?: true;
+    readonly taskDeliveries?: readonly import('./task-delivery.ts').TaskDelivery[];
+    readonly reconciliationSessions?: Record<string, number>;
+    readonly reconciliationReminders?: Record<string, import('./reconciliation-state.ts').ReminderState>;
     readonly tasks: readonly TaskRecord[];
     readonly archived?: readonly ArchivedRecord[];
     /** #114 S4: the bounded ring of refused / would-be-refused settlements. */

package/lib/types/task-ledger.d.ts

@@ -19,6 +19,8 @@
  * @module @nelsonlongxiang/dsh-open-a2a-net/task-ledger
  */
 import type { TaskAuthorization } from './task-auth.ts';
+import { type TaskDelivery } from './task-delivery.ts';
+import { type ReminderState } from './reconciliation-state.ts';
 import { type ConservationVerdict } from './ledger-conservation.ts';
 import type { TaskRecord, ArchivedRecord, Sender, OutboundBirth, TaskLedgerOptions, ReceiptResolvedInfo, SettlementRefusalRecord, SettlementJudge, AbandonResult, CancelledResult } from './task-ledger-rows.ts';
 export * from './task-ledger-rows.ts';
@@ -45,6 +47,49 @@ export declare class TaskLedger {
     /** Injectable clock (option `now`). */
     private readonly now;
     private readonly warn;
+    /** Last successful commit, for rollback when a mutation cannot persist. */
+    private committed;
+    private deliveries;
+    private deliveryRestoreError;
+    markConsumed(taskId: string, consumed: boolean): void;
+    deliveryFor(taskId: string): TaskDelivery | undefined;
+    deliveryByMessage(sessionId: string, messageId: string): TaskDelivery | undefined;
+    reserveDelivery(record: TaskDelivery): TaskDelivery;
+    updateDelivery(taskId: string, state: TaskDelivery['state']): void;
+    private reminderRecoveryPending;
+    private reminders;
+    private reminderSessions;
+    reminderSessionAt(id: string): number | undefined;
+    reminderState(taskId: string): ReminderState | undefined;
+    /** Atomic observation update; no task status, answer, or conservation mutation. */
+    saveReminders(updates: readonly {
+        taskId: string;
+        state: ReminderState | undefined;
+    }[], session?: {
+        id: string;
+        at: number | undefined;
+    }): void;
+    private admittedFailure;
+    private admittedFailures;
+    noteAdmittedBookkeepingFailure(error: unknown): void;
+    orphanDelivery(taskId: string): boolean;
+    deliveryBookkeepingState(): {
+        orphaned: number;
+        failures: number;
+        lastError?: {
+            at: number;
+            code: string;
+        };
+    };
+    private writeFailure;
+    /** Diagnostic-only; never implies that a failed mutation committed. No paths or payloads exposed. */
+    persistenceState(): {
+        ok: boolean;
+        lastError?: {
+            at: number;
+            code: string;
+        };
+    };
     /**
      * @param path - persistence file (`<dsh-home>/a2a/tasks.json`); empty = no persistence.
      * @param options - TTL/capacity overrides; defaults come from the exported constants.
@@ -99,7 +144,7 @@ export declare class TaskLedger {
      * @param from - the caller's receipt target (label or callback address).
      * @param contextId - the delivery's conversation id, kept for follow-up routes (empty omits it).
      */
-    trackInbound(taskId: string, team: string, from: string, contextId?: string, receiptExpected?: boolean, brief?: string, auth?: TaskAuthorization, deliveredTo?: string): void;
+    trackInbound(taskId: string, team: string, from: string, contextId?: string, receiptExpected?: boolean, brief?: string, auth?: TaskAuthorization, deliveredTo?: string, receiverSessionId?: string, consumed?: boolean): void;
     /** Record an answer only from the local member that actually received this row; never settle or change counters. */
     markAnswered(taskId: string, target: string): boolean;
     /**
@@ -138,6 +183,7 @@ export declare class TaskLedger {
      * the route layer reads team/contextId from here for its best-effort
      * steer, which is the documented boundary until origin-auth lands.
      */
+    recordWithdrawalResult(taskId: string, result: import('./task-ledger-rows.ts').WithdrawalResult): void;
     cancel(taskId: string, reason?: string): CancelledResult;
     /**
      * Correlate one message against the ledger: a receipt (message starting
@@ -204,4 +250,5 @@ export declare class TaskLedger {
     private restore;
     /** Persist the ledger (no-op when no path was configured). */
     private persist;
+    private snapshot;
 }

package/lib/types/tools/info.d.ts

@@ -14,6 +14,7 @@ import type { TaskLedger } from '../task-ledger.ts';
 import type { TeamMembershipStore } from '../team-store.ts';
 /** One directory row shared with listDirectoryTeams (which stays in index.ts). */
 export type DirectoryTeamRow = {
+    memberRef?: string;
     team: string;
     session: string;
     name: string;
@@ -41,9 +42,11 @@ export interface InfoToolsDeps {
     readonly ownCardUrl: string;
     readonly peerStore: PeerStore;
     readonly taskLedger: TaskLedger;
+    readonly nudgeEscalations?: () => import('../nudge-observability.ts').NudgeEscalations;
     readonly joinedSessions: JoinedSessions;
     readonly teamMemberships: TeamMembershipStore;
     readonly canvasStore: CanvasStore;
+    readonly canvasMigrationState: () => Record<string, unknown>;
     readonly exposureStore: ExposureStore;
     readonly idempotencyStore: IdempotencyStore;
     readonly cardCache: Map<string, CardCacheEntry>;

package/lib/types/types.d.ts

@@ -2,6 +2,7 @@
  * Wire and configuration vocabulary for the A2A client extension.
  * @module @nelsonlongxiang/dsh-open-a2a-net/types
  */
+import type { RECEIPT_RETRYABLE } from './receipt-retry.ts';
 /** One peer node's agent card — the decentralized discovery record. */
 export interface A2aPeerCard {
     /** Human-facing peer name. */
@@ -108,6 +109,7 @@ export interface ZoneRecord {
 }
 /** Canonical `a2a_route` success value. */
 export interface A2aRouteOk {
+    readonly receiverBookkeeping?: 'failed';
     /** Actual member face returned by a forwarded peer delivery. */
     readonly deliveredTo?: string;
     /**
@@ -150,6 +152,7 @@ export interface A2aRouteOk {
 }
 /** Canonical `a2a_route` failure value. */
 export interface A2aRouteError {
+    readonly [RECEIPT_RETRYABLE]?: true;
     /** A forwarded receipt never promises another receipt, including uncertain waits. */
     readonly receipt?: 'none';
     readonly ok: false;

package/nexus-stage/src/federation.ts

@@ -69,6 +69,7 @@ export function peerHostOf(url: string): string {
 
 /** One remote team row as the directory reports it (state.remote). */
 export interface RemoteTeamRow {
+  memberRef?: string
   team: string
   unreachable?: boolean
   name?: string

package/nexus-stage/src/main.ts

@@ -299,14 +299,28 @@ const bench = createWorkbench({
       return { ...body, ok: res.ok && body.ok === true }
     } catch (error) { return { ok: false, error: String(error) } }
   },
-  async canvasOp(action, name, id, home) {
+  async confirmMember(name, id, replacement, revision, expectedOwner, peer) {
+    try {
+      const response=await controlFetch('/__dsh_a2a/canvas',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({action:'confirm-member',name,id,replacement,revision,expectedOwner,...(peer?{peer}:{})})})
+      const body=await response.json() as {ok?:boolean;error?:string}
+      return {ok:response.ok&&body.ok===true,error:body.error}
+    }catch(error){return{ok:false,error:String(error)}}
+  },
+  async regulateSuspended(action, name, id, revision, expected) {
+    try {
+      const response = await controlFetch('/__dsh_a2a/canvas', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ action, name, id, revision, expected }) })
+      const body = await response.json() as { ok?: boolean; error?: string }
+      return { ok: response.ok && body.ok === true, error: body.error }
+    } catch (error) { return { ok: false, error: String(error) } }
+  },
+  async canvasOp(action, name, id, home, peer) {
     // Same control route the planning board's wire uses; the inspector's
     // member writes are one id at a time, so no serial fan-out needed.
     try {
       const res = await controlFetch('/__dsh_a2a/canvas', {
         method: 'POST',
         headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ action, name, id, ...(home === undefined ? {} : { home }) }),
+        body: JSON.stringify({ action, name, id, ...(home === undefined ? {} : { home }), ...(peer === undefined ? {} : { peer }) }),
       })
       const body = (await res.json().catch(() => ({}))) as { ok?: boolean; error?: string }
       if (res.ok && body.ok !== false) return true
@@ -479,6 +493,7 @@ async function poll(): Promise<void> {
       .filter(r => r !== null && typeof r === 'object' && typeof (r as { team?: unknown }).team === 'string' && typeof (r as { via?: unknown }).via === 'string')
       .map(r => ({
         team: r.team,
+        memberRef:r.memberRef,
         name: r.name,
         via: r.via,
         workspace: r.workspace,

package/nexus-stage/src/member-provenance-picker.ts

@@ -0,0 +1,13 @@
+/** Explicit slot provenance confirmation; never clears suspension or infers owner from a label. */
+export interface ProvenanceChoice { replacement: string; label: string; peer?: string }
+export function createMemberProvenancePicker(choices: readonly ProvenanceChoice[], confirm: (choice: ProvenanceChoice) => Promise<{ ok: boolean; error?: string }>): HTMLElement {
+ const root=document.createElement('form');root.className='wb-member-provenance'
+ const select=document.createElement('select');select.setAttribute('aria-label','确认成员来源')
+ select.appendChild(new Option('明确选择来源…',''))
+ choices.forEach((choice,index)=>select.appendChild(new Option(choice.label,String(index))))
+ const submit=document.createElement('button');submit.type='submit';submit.textContent='确认来源'
+ const hint=document.createElement('span');hint.textContent='确认不等于恢复；已暂停槽位仍保持暂停'
+ root.append(select,submit,hint)
+ root.addEventListener('submit',async event=>{event.preventDefault();if(select.value==='')return;const choice=choices[Number(select.value)];if(!choice)return;submit.disabled=true;const out=await confirm(choice);if(!out.ok){submit.disabled=false;hint.textContent=out.error??'来源无法验证，原槽位保留'}else hint.textContent='来源已确认；等待状态刷新（暂停状态不变）'})
+ return root
+}

package/nexus-stage/src/planning-member-handles.ts

@@ -2,7 +2,7 @@
 import type { RemoteTeamRow } from './federation'
 import type { SessionLite } from './world'
 
-type HandleSession = Pick<SessionLite, 'id' | 'team' | 'joined'>
+type HandleSession = Pick<SessionLite, 'id' | 'team' | 'joined' | 'memberRef'>
 
 /** Map only unique joined id8 handles that no remote directory row already owns. */
 export function joinedLocalIdsByHandle(sessions: ReadonlyArray<HandleSession>, publishedHandles: ReadonlySet<string>): Map<string, string> {
@@ -21,6 +21,9 @@ export function joinedLocalIdsByHandle(sessions: ReadonlyArray<HandleSession>, p
       localIds.set(handle, session.id)
     }
   }
+  const ownerAliases=new Map<string,string[]>()
+  for(const session of sessions)if(session.joined===true && session.memberRef){const ids=ownerAliases.get(session.memberRef)??[];ids.push(session.id);ownerAliases.set(session.memberRef,ids)}
+  for(const [ref,ids]of ownerAliases)if(ids.length===1)localIds.set(ref,ids[0]!)
   return localIds
 }
 

package/nexus-stage/src/planning-view.ts

@@ -1236,7 +1236,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
         const host = peerHostOf(p.url)
         // Owner report 2026-11-04: the host's rows now lead with its bare process team (e.g. 'dsh'), which the
         // server reads as a local session id and refuses — take the first zone/id8 SESSION handle instead.
-        const handle = lastRemoteTeams.get(host)?.find(row => row.team.includes('/'))?.team
+        const first = lastRemoteTeams.get(host)?.find(row => row.team.includes('/')); const handle = first?.memberRef ?? first?.team
         model.upsertNode({
           id, x: base.x, y: base.y,
           label: p.url, team: '', name: p.url, peerUrl: p.url,
@@ -1262,7 +1262,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
       let y = hostNode?.y ?? 0
       for (const row of rows) {
         if (!row.team.includes('/')) continue
-        const id = `member-${row.team.replace(/[^a-z0-9-]/gi, '-')}`
+        const id = `member-${(row.memberRef ?? row.team).replace(/[^a-z0-9-]/gi, '-')}`
         if (memberSeen.has(id)) continue
         memberSeen.add(id)
         const saved = layoutDoc?.nodes[id]
@@ -1272,7 +1272,7 @@ export function createPlanningView(deps: PlanningDeps): PlanningView {
         model.upsertNode({
           id, x: pos.x, y: pos.y,
           label: row.team, team: row.team, name: row.name !== undefined && row.name !== '' ? row.name : row.team,
-          remoteHandle: row.team,
+          remoteHandle: row.memberRef ?? row.team,
           live: true, remote: true, memberships: [],
         })
       }

package/nexus-stage/src/workbench.ts

@@ -21,6 +21,7 @@
 import { createChatDrawer, type ChatTarget } from './wb-chat'
 import { createSeatNameEditor } from './seat-name-editor'
 import { createCliHomePicker, type CliHomeOptions } from './cli-home-picker'
+import { createMemberProvenancePicker, type ProvenanceChoice } from './member-provenance-picker'
 import { createRailTabs } from './wb-rail'
 import { DIRECTORY_FILTERS, learnLogTitle, loadLogTitles, renderDirectory, type DirFilter } from './wb-directory'
 import { ledgerFacts, renderLedger as paintLedger } from './wb-ledger'
@@ -92,6 +93,7 @@ export interface PeerOrgRow {
 
 /** One session row from /state `sessions` (live or cold joined). */
 export interface SessionRow {
+  readonly memberRef?: string
   readonly id: string
   readonly label: string
   readonly team: string
@@ -112,6 +114,7 @@ export interface SessionRow {
 
 /** One remote team row from /state `remote`. */
 export interface RemoteRow {
+  readonly memberRef?: string
   readonly team: string
   readonly unreachable?: boolean
   readonly name?: string
@@ -128,6 +131,7 @@ export interface RemoteRow {
  *  handle (`zone/id8`) — remote members are routed by the directory, never
  *  woken locally (0.6.6 unified team model). */
 export interface CanvasMemberRow {
+  readonly provenance?: 'legacy-inferred' | 'unknown'
   readonly id: string
   readonly team?: string
   readonly joined?: boolean
@@ -160,7 +164,7 @@ export interface StateBody {
   readonly zone?: string
   readonly version?: string
   readonly sessions?: readonly SessionRow[]
-  readonly canvas?: { teams?: readonly CanvasTeamRow[] }
+  readonly canvas?: { teams?: readonly CanvasTeamRow[]; revision?: number; memberSlots?: ReadonlyArray<{ name: string; member: string; ownerKey: string | null; provenance: string; suspended: boolean; compatibilityInference: boolean }>; retainedMembers?: ReadonlyArray<{ team: string; member: string; suspended: boolean; records: readonly unknown[] }> }
   /** gh#20 W-A/W-C: the peer row carries the link badge source, the host
    *  rail's label/version/last-contact facts (absent on older hosts). */
   readonly peers?: ReadonlyArray<{
@@ -219,8 +223,10 @@ export interface WorkbenchDeps {
   abandon(taskId: string, reason: string): Promise<boolean>
   /** Canvas team member change via the control route (0.6.6): `id` is a
    *  local session id or a zone-qualified remote handle. True on success. */
-  canvasOp(action: 'add-member' | 'remove-member', name: string, id: string, home?: string): Promise<boolean>
+  canvasOp(action: 'add-member' | 'remove-member', name: string, id: string, home?: string, peer?: string): Promise<boolean>
   cliHomeOptions?(name: string, id: string): Promise<CliHomeOptions>
+  confirmMember?(name: string, id: string, replacement: string, revision: number, expectedOwner: string | null, peer?: string): Promise<{ ok: boolean; error?: string }>
+  regulateSuspended?(action: 'restore-suspended' | 'delete-suspended', name: string, id: string, revision: number, expected: readonly unknown[]): Promise<{ ok: boolean; error?: string }>
   /** Quick dispatch (0.6.9): POST /__dsh_a2a/dispatch as a human gesture —
    *  one message to a routing team, async delivery, receipt lands in the
    *  ledger. Optional — without it the 快派 form hides. */
@@ -342,6 +348,7 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
   // by team name — same trick as draftForm so inputs survive the 3s poll).
   let canvasForm: { name: string; form: HTMLFormElement; pick: HTMLSelectElement; manual: HTMLInputElement } | null = null
   const cliHomeForms = new Map<string, HTMLFormElement>()
+  const provenanceForms = new Map<string, HTMLElement>()
   // Quick-dispatch form (0.6.9), cached per target routing team the same
   // draftForm way: a textarea's draft must survive the 3s poll remount.
   let dispatchForm: { team: string; form: HTMLFormElement; text: HTMLTextAreaElement; note: HTMLElement } | null = null
@@ -981,7 +988,7 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
       for (const member of fresh.members) {
         const row = el('div', 'wb-member-row')
         const dot = member.cliHeld === true ? '本机持有，无需指定' : member.remote === true ? (member.cliHome === null ? '◇ 远端 · home 未确定' : '◇ 远端') : member.live === true ? '● 现场' : member.joined === true ? '○ 冷启' : '· 未入网'
-        row.appendChild(el('span', 'wb-member-dot')).textContent = dot
+        row.appendChild(el('span', 'wb-member-dot')).textContent = dot + (member.provenance ? ' · 来源未确认' + (member.provenance === 'legacy-inferred' ? '（兼容推断）' : '') : '')
         const label = el('span', 'wb-member-label')
         const session = (last?.sessions ?? []).find(s => s.id === member.id)
         label.textContent = member.remote === true ? member.id : (session !== undefined ? displayName(session) : member.id)
@@ -1011,6 +1018,37 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
           card.appendChild(form)
         }
       }
+      const retained = (last?.canvas?.retainedMembers ?? []).filter(r => r.team === fresh.name)
+      for (const slot of retained) {
+        const row = el('div', 'wb-member-row')
+        row.appendChild(el('span', 'wb-member-dot')).textContent = slot.suspended ? '已暂停 · 不参与路由' : '来源未确认 · 窗口关闭'
+        row.appendChild(el('span', 'wb-member-label')).textContent = slot.member
+        if (slot.suspended && deps.regulateSuspended && last?.canvas?.revision !== undefined) {
+          for (const action of ['restore-suspended', 'delete-suspended'] as const) {
+            const button = el('button', 'wb-member-remove'); button.type = 'button'
+            button.textContent = action === 'restore-suspended' ? '显式恢复' : '删除暂停位'
+            const revision = last.canvas.revision
+            button.addEventListener('click', async () => {
+              button.disabled = true
+              const result = await deps.regulateSuspended!(action, fresh.name, slot.member, revision, slot.records)
+              if (!result.ok) { button.disabled = false; button.title = result.error ?? '状态已变，请刷新后重试' }
+            })
+            row.appendChild(button)
+          }
+        }
+        card.appendChild(row)
+      }
+      for (const slot of last?.canvas?.memberSlots ?? []) {
+        if (slot.name !== fresh.name || slot.provenance !== 'unknown' || !deps.confirmMember || last?.canvas?.revision === undefined) continue
+        const badge=el('div','wb-hint');badge.textContent=slot.member+' · 来源未确认'+(slot.compatibilityInference?' · 兼容推断中':'')+(slot.suspended?' · 已暂停':'');card.appendChild(badge)
+        const choices: ProvenanceChoice[]=(last.sessions??[]).filter(s=>s.joined===true).map(s=>({replacement:s.id,label:displayName(s)+' — 本机完整会话'}))
+        for(const remote of last.remote??[])if(remote.team.includes('/') && remote.via)choices.push({replacement:remote.team,label:displayName(remote)+' — '+remote.via,peer:remote.via})
+        const revision=last.canvas.revision
+        const formKey=JSON.stringify([fresh.name,slot.member,revision,slot.ownerKey,choices])
+        let form=provenanceForms.get(formKey)
+        if(!form){form=createMemberProvenancePicker(choices,choice=>deps.confirmMember!(fresh.name,slot.member,choice.replacement,revision,slot.ownerKey,choice.peer));provenanceForms.set(formKey,form)}
+        card.appendChild(form)
+      }
       // Add-member form: static DOM re-mounted per poll (draftForm trick) —
       // rebuilt only when the inspected team changes.
       if (canvasForm?.name !== fresh.name) {
@@ -1032,10 +1070,11 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
         form.addEventListener('submit', async ev => {
           ev.preventDefault()
           const handle = manual.value.trim()
-          const id = handle !== '' ? handle : pick.value
+          const selected=handle!==''?undefined:pick.selectedOptions[0]
+          const id = handle !== '' ? handle : selected?.dataset.member ?? pick.value
           if (id === '') return
           submit.disabled = true
-          const ok = await deps.canvasOp('add-member', fresh.name, id)
+          const ok = await deps.canvasOp('add-member', fresh.name, id, undefined, selected?.dataset.peer)
           submit.disabled = false
           if (ok) manual.value = ''
         })
@@ -1067,7 +1106,10 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
           pick.appendChild(new Option('远端会话队（目录卡片）…', '', true, false))
           remoteLabeled = true
         }
-        pick.appendChild(new Option(`${displayName(remote)} — 远端`, remote.team))
+        const option=new Option(`${displayName(remote)} — ${remote.via ?? '来源未确认'}`, JSON.stringify([remote.team,remote.via]))
+        option.dataset.member=remote.team
+        if(remote.via)option.dataset.peer=remote.via
+        pick.appendChild(option)
       }
       if (!remoteLabeled) {
         pick.appendChild(new Option('（暂无可拉入的远端会话队——见下方说明）', '', true, false))
@@ -1076,7 +1118,7 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
       card.appendChild(canvasForm.form)
       const hint = el('div', 'wb-hint')
       hint.textContent =
-        '成员由人类在此手工分配（agent 不可自组队）。远端成员走对端目录路由，不做本机冷唤醒；地址由目录在派发时重解析。远端下拉只列 zone/id8 会话句柄——若为空，说明目录里还没有已链接对端的会话队（未链接的对端只给最小卡）；此时可在输入框手输句柄（如 dsh/xxxxxxxx）先把人拉进来，句柄本身即链接手势。'
+        '成员由人类明确分配。本机写完整会话；远端必须通过已链接主机的有效名片核实并记录完整公钥来源。最小卡、离线或第三方无法验证时保留待确认，不能手输裸句柄绕过来源校验。来源确认不恢复暂停；默认兼容窗口不自动关闭。'
       card.appendChild(hint)
       // Quick dispatch targets the canvas ROUTING team (0.6.9): local tiers
       // first, then the remote members in order — the seam's own priority.
@@ -1230,6 +1272,8 @@ export function createWorkbench(deps: WorkbenchDeps): Workbench {
   function update(state: StateBody | null): void {
     const unknown = new Set((state?.canvas?.teams ?? []).flatMap(team => team.members.filter(member => member.cliHome === null && member.cliHeld !== true).map(member => JSON.stringify([team.name, member.id]))))
     for (const key of cliHomeForms.keys()) if (!unknown.has(key)) cliHomeForms.delete(key)
+    const slots=state?.canvas?.memberSlots??[]
+    for(const key of provenanceForms.keys()){const [name,member,revision]=JSON.parse(key) as [string,string,number];if(revision!==state?.canvas?.revision||!slots.some(slot=>slot.name===name&&slot.member===member&&slot.provenance==='unknown'))provenanceForms.delete(key)}
     last = state
     // 0.6.12: refresh the readable-log list opportunistically (single flight;
     // the sidebar re-renders when rows land, mid-poll remount is idempotent).

package/nexus-stage/src/world.ts

@@ -154,6 +154,7 @@ export function planSeatClear(sid: string, occupied: ReadonlyArray<{ readonly x:
 
 /** Minimal session row shape the model needs (topology.SessionRow satisfies it). */
 export interface SessionLite {
+  memberRef?: string
   id: string; label: string; team: string; name?: string; description?: string; joined: boolean; live?: boolean; teams?: readonly string[]
   /** Live local sessions only: mid-turn ('running') or idle, and how many receipt-owing tasks wait on it. */
   status?: 'running' | 'idle'; queued?: number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nelsonlongxiang/dsh-open-a2a-net",
-  "version": "0.6.42",
+  "version": "0.7.0",
   "description": "Open A2A network plugin for DeepSeek Harness: signed agent cards, decentralized peer/zone discovery, direct routing model tools, and joinable session nodes with a sidebar control",
   "type": "module",
   "main": "lib/index.js",
@@ -88,7 +88,8 @@
     "verify:docs": "node scripts/doc-drift.mjs",
     "reanchor:arch": "node scripts/reanchor-architecture.mjs",
     "verify:nexus": "node scripts/verify-nexus-ci.mjs && npm --prefix nexus-stage run build && npm --prefix nexus-stage run test && git diff --exit-code -- assets/nexusDist/assets && git diff --ignore-cr-at-eol --exit-code -- assets/nexusDist/index.html",
-    "verify": "pnpm typecheck && pnpm verify:docs && pnpm build && pnpm test && pnpm test:build-layout && pnpm verify:nexus"
+    "verify": "node scripts/verify-temp-clean.mjs",
+    "verify:core": "pnpm typecheck && pnpm verify:docs && pnpm build && pnpm test && pnpm test:build-layout && pnpm verify:nexus"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",