@nelsonlongxiang/dsh-open-a2a-net 0.6.33 → 0.6.34

package/lib/tools/info.js

@@ -480,12 +480,14 @@ export function createInfoTools(deps) {
                                     deadAt: { type: 'number' },
                                     direction: { type: 'string', enum: ['inbound', 'outbound'] },
                                     receiptExpected: { type: 'boolean' },
+                                    forwarded: { type: 'boolean' },
+                                    deliveredTo: { type: 'string' },
                                     reason: { type: 'string', enum: ['fire-forget', 'unconsumed'] },
                                     sender: {
                                         type: 'object',
                                         additionalProperties: false,
                                         properties: {
-                                            kind: { type: 'string', required: true, enum: ['session', 'host', 'bridge'] },
+                                            kind: { type: 'string', required: true, enum: ['session', 'host', 'bridge', 'cli'] },
                                             id: { type: 'string', required: true },
                                             face: { type: 'string' },
                                         },
@@ -506,11 +508,12 @@ export function createInfoTools(deps) {
                                     resolvedAt: { type: 'number', required: true },
                                     summary: { type: 'string' },
                                     brief: { type: 'string' },
+                                    forwarded: { type: 'boolean' },
                                     sender: {
                                         type: 'object',
                                         additionalProperties: false,
                                         properties: {
-                                            kind: { type: 'string', required: true, enum: ['session', 'host', 'bridge'] },
+                                            kind: { type: 'string', required: true, enum: ['session', 'host', 'bridge', 'cli'] },
                                             id: { type: 'string', required: true },
                                             face: { type: 'string' },
                                         },
@@ -566,7 +569,20 @@ export function createInfoTools(deps) {
                 const archiveAll = taskLedger.archive();
                 return {
                     ok: true,
-                    tasks: taskLedger.list().map(task => ({ ...task })),
+                    // 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, direction, receiptExpected, forwarded, deliveredTo, reason, sender }) => ({
+                        taskId, team, peer, startedAt, status,
+                        ...(contextId !== undefined ? { contextId } : {}),
+                        ...(brief !== undefined ? { brief } : {}),
+                        ...(deadAt !== undefined ? { deadAt } : {}),
+                        ...(direction !== undefined ? { direction } : {}),
+                        ...(receiptExpected !== undefined ? { receiptExpected } : {}),
+                        ...(forwarded !== undefined ? { forwarded } : {}),
+                        ...(deliveredTo !== undefined ? { deliveredTo } : {}),
+                        ...(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 } : {}) })),
                     archivedTotal: archiveAll.length,
                 };

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

@@ -116,7 +116,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): Promise<A2aRouteResult>;
+    routeDirect(baseUrl: string, team: string, message: string, contextId?: string, signal?: AbortSignal, callerSession?: string, asyncMode?: boolean, taskIdFromCaller?: string, callbackAddress?: string, guard?: 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/auth-observer.d.ts

@@ -49,7 +49,7 @@ export interface JudgedRow {
  * default: the birth record's `via`).
  * @returns the affected rows, in ledger order; unaffected rows are omitted.
  */
-export declare function judgeAffected(rows: readonly JudgedRow[], version: string, judge: (caller: string, target: string, ingress: 'wire' | 'local') => Admission, cacheResting?: (row: JudgedRow) => boolean): AffectedTask[];
+export declare function judgeAffected(rows: readonly JudgedRow[], version: string, judge: (caller: string, target: string, ingress: 'wire' | 'local', auth: TaskAuthorization) => Admission, cacheResting?: (row: JudgedRow) => boolean): AffectedTask[];
 /** What one {@link AuthObserver.observe} call needs from the host. */
 export interface ObserveInput {
     readonly version: string;
@@ -57,7 +57,7 @@ export interface ObserveInput {
     readonly inputs: () => unknown;
     readonly cause: string;
     readonly rows: () => readonly JudgedRow[];
-    readonly judge: (caller: string, target: string, ingress: 'wire' | 'local') => Admission;
+    readonly judge: (caller: string, target: string, ingress: 'wire' | 'local', auth: TaskAuthorization) => Admission;
 }
 /**
  * The persisted observer. One instance per host; every entry point is

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

@@ -22,6 +22,8 @@ export interface CanvasSnapshot {
         readonly name: string;
         readonly members: readonly string[];
     }>;
+    /** Pinned CLI handle -> linked home origin (only while some canvas team holds the handle). */
+    readonly cliHome?: Readonly<Record<string, string>>;
 }
 /** Upper bounds: a canvas taxonomy, not a database. */
 export declare const CANVAS_TEAM_CAP = 64;
@@ -50,6 +52,7 @@ export declare function validRemoteMemberRef(id: string): boolean;
 export declare class CanvasStore {
     /** Team entries in creation order; members in add order (routing priority). */
     private teams;
+    private cliHome;
     private readonly path;
     private readonly listeners;
     /**
@@ -74,6 +77,9 @@ export declare class CanvasStore {
     hasTeam(name: string): boolean;
     /** The named team's member ids in routing-priority order (a copy). */
     membersOf(name: string): readonly string[];
+    /** Frozen, operator-linked CLI home; undefined means unknown or ambiguous. */
+    cliHomeOf(handle: string): string | undefined;
+    pinnedCliHomes(): ReadonlyArray<readonly [string, string]>;
     /**
      * The named team's remote member refs (zone-qualified team handles) in
      * routing-priority order — the failover tier after the local live/cold
@@ -101,11 +107,14 @@ export declare class CanvasStore {
      * @param name - the existing team name.
      * @param id - the member session id.
      */
-    addMember(name: string, id: string): boolean;
+    addMember(name: string, id: string, home?: string, options?: {
+        replaceHome?: boolean;
+    }): boolean;
     /**
      * Remove one member from one team (a no-op when absent).
      */
     removeMember(name: string, id: string): boolean;
+    private forgetUnusedHome;
     /**
      * Drop one id from every team — the leave and archive paths: a session
      * leaving the network keeps no canvas membership anywhere.

package/lib/types/cli-home.d.ts

@@ -0,0 +1,24 @@
+import type { A2aPeerCard } from './types.ts';
+/** A verified, operator-linked host's full card at link time. */
+export interface CliHomeCandidate {
+    readonly url: string;
+    readonly linked: boolean;
+    readonly card?: A2aPeerCard;
+}
+/** Canonical root HTTP(S) origin; address aliases remain distinct trust decisions. */
+export declare function cliHomeOrigin(value: unknown): string | undefined;
+export type CliHomeDecision = {
+    readonly ok: true;
+    readonly home?: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** Read-only projection of the same fresh evidence used by explicit home validation. */
+export declare function cliHomeChoices(handle: string, candidates: readonly CliHomeCandidate[], locallyHeld?: boolean): {
+    homes: string[];
+    unreadable: number;
+    held?: true;
+};
+/** Count origins, not URL aliases: two card URLs on one host are one home. */
+export declare function decideCliHome(handle: string, requested: unknown, candidates: readonly CliHomeCandidate[], locallyHeld?: boolean): CliHomeDecision;

package/lib/types/client/A2aControl.d.ts

@@ -7,7 +7,7 @@ export interface A2aSessionRow {
 /** One routing outcome as the state route reports it. */
 export interface A2aActivityRow {
     readonly ts: number;
-    readonly dir: 'in' | 'out';
+    readonly dir: 'in' | 'out' | 'fwd';
     readonly team: string;
     readonly peer: string;
     readonly ok: boolean;

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

@@ -0,0 +1,32 @@
+import { type TaskLedger } from './task-ledger.ts';
+import type { A2aPeerCard, A2aRouteResult } from './types.ts';
+export interface ForwardRequest {
+    team: string;
+    message: string;
+    caller: string;
+    taskId: string;
+    contextId?: string;
+    noWait: boolean;
+    localCliProof: boolean;
+    guarded: boolean;
+}
+export interface DirectForwardDeps {
+    enabled(): boolean;
+    isolated(): boolean;
+    deposited(handle: string): boolean;
+    memberLinked(handle: string): boolean;
+    scope(handle: string, team: string): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    candidates(team: string, failures: string[], caller: string): Promise<{
+        urls: string[];
+        card(url: string): Promise<A2aPeerCard | undefined>;
+    }>;
+    dispatch(url: string, request: ForwardRequest, guard: string): Promise<A2aRouteResult>;
+    ledger: TaskLedger;
+    activity(team: string, peer: string, ok: boolean): void;
+}
+export declare function createDirectForward(d: DirectForwardDeps): (request: ForwardRequest) => Promise<A2aRouteResult>;

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

@@ -6,12 +6,13 @@ import type { Config } from '../index.ts';
 import type { CardCacheEntry, InFlightRoute, RouteActivityEntry } from '../runtime.ts';
 import { CanvasStore } from '../canvas-store.ts';
 import { type CanvasNotifyDeps } from './canvas-notify.ts';
-import type { CliDepositStore } from '../cli-deposit.ts';
+import { type CliDepositStore } from '../cli-deposit.ts';
 import type { ExposureStore } from '../exposure-store.ts';
 import type { GroupStore } from '../group-store.ts';
 import type { IdempotencyStore } from '../idempotency-store.ts';
 import type { JoinedSessions } from '../joined-store.ts';
 import type { LayoutStore } from '../layout-store.ts';
+import type { CliHomeDecision } from '../cli-home.ts';
 import type { PeerStore } from '../peer-store.ts';
 import { type TaskLedger } from '../task-ledger.ts';
 import type { TeamMembershipStore } from '../team-store.ts';
@@ -61,6 +62,12 @@ export interface AdminFaceDeps extends Pick<CanvasNotifyDeps, 'verifyOriginClaim
     readonly cliDeposits: CliDepositStore;
     readonly groupStore: GroupStore;
     readonly canvasStore: CanvasStore;
+    readonly cliHomeForAdd: (handle: string, requested?: unknown) => Promise<CliHomeDecision>;
+    readonly cliHomeOptions: (handle: string) => Promise<{
+        homes: string[];
+        unreadable: number;
+        held?: true;
+    }>;
     readonly layoutStore: LayoutStore;
     readonly taskLedger: TaskLedger;
     /** #114 S6: observe (lazily) and return the /state `authorization` block. */

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

@@ -14,13 +14,14 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import type WebServer from '@deepseek-ai/dsh-host-webserver';
-import type { A2aPeerCard } from '../types.ts';
+import type { A2aPeerCard, A2aRouteResult } from '../types.ts';
+import type { ForwardRequest } from '../direct-forward.ts';
 import { CanvasStore } from '../canvas-store.ts';
-import type { CliDepositStore } from '../cli-deposit.ts';
+import { type CliDepositStore } from '../cli-deposit.ts';
 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 SettlementRefusal, type Settler } from '../task-auth.ts';
+import { type Admission, type RemoteCliProof, type SettlementRefusal, type Settler } from '../task-auth.ts';
 import type { Config } from '../index.ts';
 /**
  * #139 (design §4.4): add `settlement: {status:'refused', reason, task_id}`
@@ -51,6 +52,7 @@ export type RouteOutcome = {
 } | {
     ok: false;
     error: string;
+    localMiss?: true;
 };
 interface BridgeTeamsRegistryMirror {
     listTeams(): Array<{
@@ -127,6 +129,10 @@ export interface WireDeps {
     readonly verifyOriginClaim: (req: IncomingMessage, options?: {
         readonly cli?: boolean;
     }) => Promise<OriginClaimResult>;
+    readonly forwardDirect: (request: ForwardRequest) => Promise<A2aRouteResult>;
+    readonly remoteCliProof: (handle: string, claim: Extract<OriginClaimResult, {
+        ok: true;
+    }>) => Promise<RemoteCliProof | undefined>;
     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;
@@ -135,7 +141,7 @@ export interface WireDeps {
     readonly secretEqual: (a: string, b: string) => 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) => Admission;
+    readonly a2aCallerAdmission: (caller: string, targetTeam?: string, cliProof?: RemoteCliProof) => 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). */
@@ -159,6 +165,8 @@ export interface WireDeps {
     };
     readonly taskLedger: TaskLedger;
     readonly refuseIfFlooded: (caller: string, message: string, team: string, taskId: string, res: ServerResponse) => boolean;
+    /** gh#224: refuses a new delivery once the target already owes `targetQueueCap` receipts. */
+    readonly refuseIfQueueFull: (caller: string, message: string, team: string, taskId: string, mailbox: boolean, res: ServerResponse) => boolean;
     /** Settles a receipt; returns the enforce refusal of the row its header names (#139), if any. */
     readonly settleAndAnnounce: (message: string, settler?: Settler) => SettlementRefusal | undefined;
     readonly touchWakeDemand: () => void;

package/lib/types/index.d.ts

@@ -91,6 +91,8 @@ export interface Config {
      * (which is left untouched). Inbound faces keep answering. Default false.
      */
     readonly isolated: boolean;
+    /** Forward online local CLI deliveries one hop after a local miss. Default off. */
+    readonly forwardDirect: boolean;
     /** Human-facing name published on the agent card. */
     readonly agentName: string;
     /**
@@ -258,6 +260,8 @@ export interface Config {
      * v0.5.23 (async-stall): see the schema comment on asyncNudgeDelayMs.
      */
     readonly asyncNudgeDelayMs: number;
+    /** gh#224: receipt-owing tasks one target may queue on this host before new deliveries are refused (0 = off). */
+    readonly targetQueueCap: number;
     /**
      * How long the state route serves the cold-row id set from cache before
      * re-enumerating the persistence layer. The panel polls every 2s; the

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

@@ -0,0 +1,21 @@
+/** One sender scope gate shared by model routing and home-host CLI forwarding. */
+export interface OutboundScopeRecords {
+    readonly zone: string;
+    teamsOf(id: string): readonly string[];
+    membersOf(team: string): readonly string[];
+    id8(id: string): string;
+    canvasNames(): readonly string[];
+    canvasMembers(name: string): readonly string[];
+    canvasTeam(name: string): string;
+    peerOrgs(): Iterable<readonly {
+        team?: unknown;
+        members?: unknown;
+    }[]>;
+    warmPeers(): Promise<unknown>;
+}
+export declare function outboundScope(r: OutboundScopeRecords, id: string, handle: string, team: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -0,0 +1,32 @@
+/** gh#224 per-target queue cap (owner 2026-11-03: "at most 3 queued"). The flood guard (gh#91)
+ * bounds a sender's RATE; a slow, steady sender can still pile a dozen unanswered tasks onto one
+ * busy session. This counts what the target already owes and refuses a NEW delivery once the
+ * count reaches the cap, visibly and before anything is steered or booked.
+ *
+ * Counted ("queued for T"): rows this host's ledger still holds pending for T that expect a
+ * receipt — inbound rows born at /a2a/direct (addressed to T, or delivered to T), and same-host
+ * routes (peer 'local') to T. Never refused: a receipt for a task this host's ledger holds
+ * (terminal; refusing one strands that row — a genuine receipt always returns to the host that
+ * booked its task, so a '[A2A receipt]' header naming an unknown id is ordinary traffic and is
+ * counted), and deliveries into a CLI mailbox (its own 64-mail bound applies). A canvas team is
+ * one target: a full queue refuses the team as addressed, remote members included.
+ */
+import type { ServerResponse } from 'node:http';
+import type { IdempotencyStore } from './idempotency-store.ts';
+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 team: string;
+    readonly peer: string;
+    readonly status: string;
+    readonly direction?: string;
+    readonly receiptExpected?: boolean;
+    readonly deliveredTo?: string;
+}
+/** How many receipt-owing tasks this host holds pending for `team`. */
+export declare function queuedFor(rows: readonly QueueRow[], team: string): number;
+/** 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;
+/** 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;

package/lib/types/runtime.d.ts

@@ -11,7 +11,7 @@ import type { A2aPeerCard } from './types.ts';
  */
 export interface RouteActivityEntry {
     readonly ts: number;
-    readonly dir: 'in' | 'out';
+    readonly dir: 'in' | 'out' | 'fwd';
     readonly team: string;
     readonly peer: string;
     readonly ok: boolean;

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

@@ -1,7 +1,7 @@
 /** The admission basis (closed set, design §2.2). */
 export type Via = 'host-face' | 'joined-session' | 'canvas-member' | 'peer-org' | 'cli-deposit' | 'open';
 /** The exact rule that admitted a caller (closed set, design §2.2). */
-export type AdmissionRule = 'scope-off' | 'host-face' | 'local-exempt' | 'roster-shared' | 'canvas-shared' | 'remote-ref-samezone' | 'remote-ref-foreign' | 'peer-org' | 'node-fact' | 'cli-deposit';
+export type AdmissionRule = 'scope-off' | 'host-face' | 'local-exempt' | 'roster-shared' | 'canvas-shared' | 'remote-ref-samezone' | 'remote-ref-foreign' | 'remote-ref-cli' | 'peer-org' | 'node-fact' | 'cli-deposit';
 /** Every rule's basis — the mapping the authorization record stores beside the rule. */
 export declare const VIA_OF: Readonly<Record<AdmissionRule, Via>>;
 /**
@@ -49,6 +49,15 @@ export interface AdmissionRecords {
     peerOrgs(): Iterable<readonly PeerOrgEntry[]>;
     liveNodeIds(): readonly string[];
     cliDeposited(handle: string): boolean;
+    /** An operator-pinned CLI home, absent for ambiguous/unlinked CLI refs. */
+    cliHomeOf?(handle: string): string | undefined;
+}
+/** Bound signer evidence and a fresh full-card online check, never caller self-description. */
+export interface RemoteCliProof {
+    readonly origin: string;
+    readonly viaUrl: string;
+    readonly bound: boolean;
+    readonly online: boolean;
 }
 /**
  * W1/W2 shared-team admission core: a same-zone zone/id8 caller passes when
@@ -73,7 +82,9 @@ export declare function joinedFaceAdmission(r: AdmissionRecords, callerSession:
  */
 export declare function localCandidateAdmission(r: AdmissionRecords, callerSession: string | undefined, targetTeam?: string): Admission;
 /** Inbound admission for the peer faces (/a2a/direct, /a2a/log): caller_session is the contract. */
-export declare function callerAdmission(r: AdmissionRecords, caller: string, targetTeam?: string): Admission;
+export declare function callerAdmission(r: AdmissionRecords, caller: string, targetTeam?: string, cliProof?: RemoteCliProof): Admission;
+/** Revalidate only mutable operator authority, not already-verified birth-time identity or liveness. */
+export declare function recheckRemoteCliAuthorization(r: AdmissionRecords, auth: TaskAuthorization): Admission;
 /**
  * The inputs of the allowlist version (design §2.3): only operator-controlled
  * records the admission rules really read. The peer-card canvasOrg is left
@@ -87,6 +98,7 @@ export interface AllowlistInputs {
     readonly roster: readonly (readonly [handle: string, team: string])[];
     readonly canvas: readonly (readonly [team: string, members: readonly string[]])[];
     readonly cli: readonly string[];
+    readonly cliHome?: readonly (readonly [handle: string, origin: string])[];
     readonly links: readonly string[];
 }
 /**
@@ -125,6 +137,8 @@ export interface TaskAuthorization {
     };
     readonly ingress: 'wire' | 'local';
     readonly via: Via;
+    /** Signed courier host's card URL for a remote CLI, distinct from the closed-set admission via. */
+    readonly carrier_url?: string;
     readonly admission_rule: AdmissionRule;
     /** Every shared team that held (cache-owed ones as `peer-org:<team>`). */
     readonly basis: readonly string[];
@@ -152,6 +166,7 @@ export interface AuthorizationFacts {
         readonly caller: string;
         readonly origin: string;
     };
+    readonly carrierUrl?: string;
     readonly ingress: 'wire' | 'local';
     readonly allowlistVersion: string;
     readonly target: string;

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

@@ -63,7 +63,7 @@ export type ArchiveEnd = 'receipt' | 'echo' | 'abandoned' | 'cancelled' | 'evict
  * same-host seats could not be told apart.
  */
 export interface Sender {
-    readonly kind: 'session' | 'host' | 'bridge';
+    readonly kind: 'session' | 'host' | 'bridge' | 'cli';
     /**
      * A session's `<zone>/<id8>` node team, the host process label, or the
      * bridge submitter. Group senders by `kind:id`, never by `id` alone: a host
@@ -89,6 +89,7 @@ export declare const SENDER_ID_CAP = 256;
 export declare function parseSender(raw: unknown): Sender | undefined;
 /** #139: what an outbound row is born with besides its sender. */
 export interface OutboundBirth {
+    readonly forwarded?: true;
     /** The local-candidate admission (ingress local); kept only on a row whose peer is 'local'. */
     readonly auth?: TaskAuthorization;
     readonly peerKey?: string;
@@ -124,6 +125,8 @@ export interface TaskRecord {
     readonly brief?: string;
     /** #114 S3: the real sender of an outbound row (absent on inbound rows and rows persisted before the field). */
     readonly sender?: Sender;
+    /** Home host forwarded an online CLI request to a peer. */
+    readonly forwarded?: true;
     /**
      * #114 S2: the immutable authorization the row was born with — an inbound
      * row's wire admission, or (#139) an outbound row's local-candidate
@@ -183,6 +186,8 @@ export interface ArchivedRecord {
     readonly receiptExpected?: false;
     /** #114 S3: copied from the owed row (absent on inbound rows and rows archived before the field). */
     readonly sender?: Sender;
+    /** Home host forwarded an online CLI request to a peer. */
+    readonly forwarded?: true;
     /** #114 S2: carried over from the live row unchanged. */
     readonly auth?: TaskAuthorization;
     /** #139: carried over from the live row unchanged (a late receipt is judged against them). */

package/lib/types/types.d.ts

@@ -76,6 +76,8 @@ export interface A2aSessionTeamInfo {
     readonly name: string;
     /** One-line excerpt of the session's newest user or assistant text. */
     readonly description: string;
+    /** CLI deposit status, explicitly online/offline on full host cards; absent on ordinary sessions. */
+    readonly offline?: boolean;
     /** The session's working directory, when the publishing node shares it. */
     readonly workspace?: string;
 }
@@ -105,6 +107,8 @@ export interface ZoneRecord {
 }
 /** Canonical `a2a_route` success value. */
 export interface A2aRouteOk {
+    /** Actual member face returned by a forwarded peer delivery. */
+    readonly deliveredTo?: string;
     readonly ok: true;
     readonly team: string;
     /** Reply text the remote team produced. */
@@ -129,6 +133,8 @@ export interface A2aRouteOk {
      * receipt-owed (`trackOwedTask` skips it).
      */
     readonly bridge?: 'native-teams';
+    /** The peer's explicit receipt contract, when provided. */
+    readonly receipt?: 'none' | 'routed' | 'mailbox';
     /**
      * gh#141: the peer refused the settlement the delivered message carried
      * (its enforce verdict, `settlement: {status: 'refused'}` on the wire,
@@ -138,6 +144,8 @@ export interface A2aRouteOk {
 }
 /** Canonical `a2a_route` failure value. */
 export interface A2aRouteError {
+    /** A forwarded receipt never promises another receipt, including uncertain waits. */
+    readonly receipt?: 'none';
     readonly ok: false;
     /** Peer or transport failure text. */
     readonly error: string;

package/nexus-stage/src/cli-home-picker.ts

@@ -0,0 +1,42 @@
+/** Explicit operator choice only; this form never auto-selects or relaxes home admission. */
+export interface CliHomeOptions { ok: boolean; homes?: string[]; unreadable?: number; held?: boolean; error?: string }
+export function createCliHomePicker(read: () => Promise<CliHomeOptions>, save: (home: string) => Promise<boolean>): HTMLFormElement {
+  const form = document.createElement('form')
+  form.className = 'wb-cli-home'
+  const readButton = document.createElement('button')
+  readButton.type = 'button'; readButton.textContent = '指定 home'; readButton.className = 'wb-member-submit'
+  const select = document.createElement('select')
+  select.className = 'wb-member-pick'; select.setAttribute('aria-label', '选择 CLI home 主机'); select.hidden = true
+  const submit = document.createElement('button')
+  submit.type = 'submit'; submit.textContent = '确认 home'; submit.className = 'wb-member-submit'; submit.hidden = true; submit.disabled = true
+  const note = document.createElement('div')
+  note.className = 'wb-hint'; note.setAttribute('role', 'status'); note.setAttribute('aria-live', 'polite')
+  note.textContent = 'home 未确定；点击指定 home 现读已链接主机名片。'
+  let busy = false
+  readButton.addEventListener('click', async () => {
+    if (busy) return
+    busy = true; readButton.disabled = true; submit.disabled = true; note.textContent = '正在现读主机名片…'
+    try {
+      const result = await read()
+      if (!result.ok) throw Error(result.error ?? '候选读取失败')
+      if (result.held) { readButton.hidden = true; select.hidden = true; submit.hidden = true; select.replaceChildren(); note.textContent = '本机持有，无需指定'; return }
+      select.replaceChildren(new Option('请选择 home 主机…', '', true, true))
+      for (const home of result.homes ?? []) select.appendChild(new Option(home, home))
+      select.hidden = false; submit.hidden = false; readButton.textContent = '刷新候选'
+      const count = result.homes?.length ?? 0
+      note.textContent = (result.unreadable ? '有 ' + result.unreadable + ' 台对端名片读不到；' : '') + (count > 1 ? '多台已链接主机列出该句柄，请显式选择。' : count === 1 ? '找到 1 台已链接主机；仍需你显式确认。' : '当前没有已链接且列出该句柄的可选主机。')
+    } catch (error) { note.textContent = '读取失败：' + String(error); select.hidden = true; submit.hidden = true }
+    finally { busy = false; readButton.disabled = false }
+  })
+  select.addEventListener('change', () => { submit.disabled = busy || select.value === '' })
+  form.addEventListener('submit', async event => {
+    event.preventDefault()
+    if (busy || select.value === '') return
+    busy = true; readButton.disabled = true; select.disabled = true; submit.disabled = true
+    try { note.textContent = await save(select.value) ? 'home 已指定：' + select.value : '指定失败：主机可能已离线或不再列出该句柄，请刷新后重选。' }
+    catch (error) { note.textContent = '指定失败：' + String(error) }
+    finally { busy = false; readButton.disabled = false; select.disabled = false; submit.disabled = select.value === '' }
+  })
+  form.append(readButton, select, submit, note)
+  return form
+}

package/nexus-stage/src/main.ts

@@ -292,14 +292,21 @@ const bench = createWorkbench({
   // The only reach primitive is the inline 快派 form: it works for local
   // session teams, canvas teams and remote rows alike, and never leaves
   // this page.
-  async canvasOp(action, name, id) {
+  async cliHomeOptions(name, id) {
+    try {
+      const res = await controlFetch('/__dsh_a2a/canvas', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ action: 'cli-home-options', name, id }) })
+      const body = await res.json() as { ok: boolean; homes?: string[]; unreadable?: number; held?: boolean; error?: string }
+      return { ...body, ok: res.ok && body.ok === true }
+    } catch (error) { return { ok: false, error: String(error) } }
+  },
+  async canvasOp(action, name, id, home) {
     // 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 }),
+        body: JSON.stringify({ action, name, id, ...(home === undefined ? {} : { home }) }),
       })
       const body = (await res.json().catch(() => ({}))) as { ok?: boolean; error?: string }
       if (res.ok && body.ok !== false) return true

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

@@ -0,0 +1,61 @@
+/**
+ * Board node card: the DOM skeleton and the right-hand chip. Extracted from planning-view so the card's static
+ * structure reads in one place and the view stays under its M1 module-size cap (1507 lines; it reached 1529 with
+ * the 工作中/空闲 chip). Pure DOM helpers — no view state; renderNodes still decides what each card shows.
+ * @module nexus-stage/planning-card
+ */
+import type { PlanningSession } from './planning-types'
+import type { WorldNode } from './world'
+
+/** The card's 工作中/空闲 chip text; empty when the host reported no status (older host, cold or remote node). */
+export function workLabel(work: Pick<PlanningSession, 'status' | 'queued'> | undefined): string {
+  if (work?.status === undefined) return ''
+  const base = work.status === 'running' ? '工作中' : '空闲'
+  return typeof work.queued === 'number' && work.queued > 0 ? `${base} · 排队 ${String(work.queued)}` : base
+}
+
+/** A fresh `.p-node` card: title row (dot + text), second row (description + 工作中/空闲 chip), and the right-hand chip. */
+export function createCardElement(id: string): HTMLDivElement {
+  const el = document.createElement('div')
+  el.className = 'p-node'
+  el.dataset.id = id
+  el.tabIndex = 0
+  const nm = document.createElement('div')
+  nm.className = 'nm'
+  const dot = document.createElement('span')
+  dot.className = 'dot'
+  const name = document.createElement('span')
+  name.className = 'nm-text'
+  nm.append(dot, name)
+  const sub = document.createElement('div')
+  sub.className = 'sub mono'
+  const prio = document.createElement('span')
+  prio.className = 'prio mono'
+  // Second line: the description, with the 工作中/空闲 chip at its right end — the title keeps its full width.
+  const work = document.createElement('span')
+  work.className = 'work'
+  const subRow = document.createElement('div')
+  subRow.className = 'sub-row'
+  subRow.append(sub, work)
+  el.append(nm, subRow, prio)
+  return el
+}
+
+/**
+ * The right-hand chip. Peer cards show the link badge (gh#20 W-A: linked green / stranger gray, then the
+ * verified tick/cross; an absent link field from an older host renders the neutral 'peer'); session cards show
+ * their first membership priority `P<n>`. Writes only on change.
+ */
+export function paintPrio(prioEl: HTMLElement, n: WorldNode, info: { link?: 'linked' | 'stranger'; verified?: boolean } | undefined): void {
+  if (n.remote === true) {
+    const cls = info?.link === 'linked' ? 'lnk-linked' : info?.link === 'stranger' ? 'lnk-stranger' : ''
+    if (prioEl.className !== `prio mono ${cls}`.trim()) prioEl.className = `prio mono ${cls}`.trim()
+    const mark = info === undefined ? '' : info.verified === true ? '✓' : '✗'
+    const badge = (info?.link ?? 'peer') + mark
+    if (prioEl.textContent !== badge) prioEl.textContent = badge
+  } else {
+    if (prioEl.className !== 'prio mono') prioEl.className = 'prio mono'
+    const prioText = n.memberships[0] !== undefined ? `P${n.memberships[0]!.index}` : ''
+    if (prioEl.textContent !== prioText) prioEl.textContent = prioText
+  }
+}