@wowyuarm/dsh-agent-team 0.1.12 → 0.1.13

package/packages/agent-team/lib/ledger.js

@@ -22,7 +22,7 @@ export function agentTeamHumanActor() {
     return HUMAN_ACTOR;
 }
 function emptyProjection() {
-    return { byRequest: new Map(), byOperation: new Map(), ordered: [], channels: new Map(), members: new Map(), memberships: new Map(),
+    return { byRequest: new Map(), byOperation: new Map(), ordered: [], channels: new Map(), members: new Map(), participations: new Map(), memberships: new Map(),
         claims: new Map(), tasks: new Map(), threads: new Map(), attention: new Map(), directMarkers: new Map(), activityMarkers: new Map(),
         orderedFacts: [], factsByThread: new Map(), channelRefByThread: new Map(), mentionsByMessage: new Map(), messageCountByThread: new Map(),
         messagesByRef: new Map(),
@@ -265,7 +265,8 @@ export class AgentTeamLedger {
             if (handle === '')
                 throw new Error('member handle must not be empty');
             if (handle !== prior.handle)
-                this.assertHandleAvailable(prior.workspaceId, handle, prior.memberId);
+                for (const workspaceId of this.workspacesOf(prior.memberId))
+                    this.assertHandleAvailable(workspaceId, handle, prior.memberId);
             this.assertModelSelection(request.model);
             this.assertCapabilities(request.capabilities);
             // An absent model or capabilities field must CLEAR any override
@@ -465,8 +466,8 @@ export class AgentTeamLedger {
             this.assertHumanActor(request.actor);
             const channel = this.requireActiveChannel(request.workspaceId, request.channelRef);
             const member = this.requireMember(request.memberId);
-            if (member.workspaceId !== request.workspaceId)
-                throw new Error('Member and Channel must belong to one Workspace');
+            if (!this.participatesIn(member.memberId, request.workspaceId))
+                throw new Error('Agent Member does not participate in the Channel\'s Workspace');
             if (member.state !== 'enabled')
                 throw new Error(`Agent Member '${member.memberId}' is ${member.state}; only enabled Members can join a Channel`);
             if (this.isChannelMember(channel.channelRef, member.memberId))
@@ -490,7 +491,7 @@ export class AgentTeamLedger {
             this.assertHumanActor(request.actor);
             const channel = this.requireChannel(request.workspaceId, request.channelRef);
             const member = this.requireMember(request.memberId);
-            if (member.workspaceId !== channel.workspaceId || !this.isChannelMember(channel.channelRef, member.memberId)) {
+            if (!this.participatesIn(member.memberId, channel.workspaceId) || !this.isChannelMember(channel.channelRef, member.memberId)) {
                 throw new Error(`Agent Member '${member.memberId}' is not a member of Channel '${channel.channelRef}'`);
             }
             const threadRefs = this.channelThreadRefs(channel.channelRef);
@@ -515,6 +516,86 @@ export class AgentTeamLedger {
             return this.committed(this.channelMemberRemovalResult(operation));
         });
     }
+    /**
+     * Join one Agent Member to one additional Workspace. Participation is a
+     * pure relation — no Session is created or moved; the Member's Session
+     * stays rooted in its default Workspace and collaboration in the joined
+     * Workspace is ledger work addressed by the workspaceId.
+     */
+    joinWorkspace(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSameWorkspaceJoin(existing, request);
+                return this.resolved(this.workspaceJoinResult(existing));
+            }
+            this.assertHumanActor(request.actor);
+            const member = this.requireMember(request.memberId);
+            if (member.state === 'inactive')
+                throw new Error(`Agent Member '${member.memberId}' is inactive and cannot join a Workspace`);
+            if (member.state === 'archived')
+                throw new Error(`Agent Member '${member.memberId}' is archived and cannot join a Workspace`);
+            if (this.participatesIn(member.memberId, request.workspaceId))
+                throw new Error(`Agent Member '${member.memberId}' already participates in Workspace '${request.workspaceId}'`);
+            // Handles resolve per Workspace: a second live Member with the same
+            // handle in the target would make mentions ambiguous there.
+            this.assertHandleAvailable(request.workspaceId, member.handle);
+            const operation = Object.freeze({
+                ...this.operationBase(request, this.nextSequence()), kind: 'team/member-workspace-joined',
+                data: Object.freeze({ workspaceId: request.workspaceId, memberId: member.memberId }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            return this.committed(this.workspaceJoinResult(operation));
+        });
+    }
+    /**
+     * Withdraw one Agent Member from one of its non-default Workspaces. The
+     * default Workspace cannot be left — ending it is the archive path. Every
+     * active Claim the Member holds on the Workspace's Threads releases with
+     * public Activities, its Attention and markers on those Threads clear, and
+     * its Channel memberships there end; identity, Session, and remaining
+     * participations are untouched.
+     */
+    leaveWorkspace(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSameWorkspaceLeave(existing, request);
+                return this.resolved(this.workspaceLeaveResult(existing));
+            }
+            this.assertHumanActor(request.actor);
+            const member = this.requireMember(request.memberId);
+            if (member.state === 'inactive')
+                throw new Error(`Agent Member '${member.memberId}' is already inactive`);
+            if (member.state === 'archived')
+                throw new Error(`Agent Member '${member.memberId}' is already archived`);
+            if (request.workspaceId === member.workspaceId)
+                throw new Error(`Agent Member '${member.memberId}' cannot leave its default Workspace '${request.workspaceId}'; archive the Member instead`);
+            if (!this.participatesIn(member.memberId, request.workspaceId))
+                throw new Error(`Agent Member '${member.memberId}' does not participate in Workspace '${request.workspaceId}'`);
+            const threadRefs = this.workspaceThreadRefs(request.workspaceId);
+            const releasedClaims = [...this.state.claims.values()]
+                .filter(claim => claim.owner === member.memberId && claim.state === 'active' && threadRefs.has(claim.threadRef))
+                .map(claim => Object.freeze({ ...claim, state: 'released' }));
+            const projectedClaims = new Map(this.state.claims);
+            for (const claim of releasedClaims)
+                projectedClaims.set(claim.claimRef, claim);
+            const sequence = this.nextSequence();
+            const activities = this.releaseSummaries(releasedClaims, member.memberId, sequence);
+            const threads = this.threadsForActivities(activities);
+            const tasks = this.tasksForClaims(releasedClaims, projectedClaims);
+            const inbox = this.removeMemberThreadInbox(member.memberId, threadRefs);
+            const operation = Object.freeze({
+                ...this.operationBase(request, sequence), kind: 'team/member-workspace-left',
+                data: Object.freeze({ workspaceId: request.workspaceId, memberId: member.memberId,
+                    claims: Object.freeze(releasedClaims), activities, tasks, threads, inbox }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            return this.committed(this.workspaceLeaveResult(operation));
+        });
+    }
     /**
      * Archive one Channel: hidden from every surface, facts kept recoverable.
      * Every active Claim on the Channel's Threads releases with one public
@@ -975,7 +1056,7 @@ export class AgentTeamLedger {
             if (body === '')
                 throw new Error('DM body must not be empty');
             const recipient = this.requireMember(request.recipientMemberId);
-            if (recipient.workspaceId !== request.workspaceId)
+            if (!this.participatesIn(recipient.memberId, request.workspaceId))
                 throw new Error(`Agent Member '${recipient.memberId}' is not in Workspace '${request.workspaceId}'`);
             if (recipient.state !== 'enabled')
                 throw new Error(`Agent Member '${recipient.memberId}' is ${recipient.state}; DM delivery requires an enabled Member`);
@@ -1030,7 +1111,16 @@ export class AgentTeamLedger {
     }
     inbox(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const limit = request.limit ?? 50;
+        return this.inboxForWorkspaces(authorized, [request.workspaceId], request.limit);
+    }
+    memberInbox(actor, request) {
+        const workspaces = this.workspacesOf(actor.memberId);
+        for (const workspaceId of workspaces)
+            this.assertActorForWorkspace(actor, workspaceId);
+        return this.inboxForWorkspaces(actor, workspaces, request.limit);
+    }
+    inboxForWorkspaces(authorized, workspaceIds, requestedLimit) {
+        const limit = requestedLimit ?? 50;
         if (!Number.isInteger(limit) || limit < 1 || limit > 100)
             throw new Error('inbox limit must be an integer between 1 and 100');
         // One unread slice serves every reader: Threads the reader follows or
@@ -1044,7 +1134,7 @@ export class AgentTeamLedger {
         // A Human reader additionally receives the separate 「最近活跃」 slice below;
         // `items` stays exactly the unread queue for every reader, so the badge
         // totals and the agent-facing `team_inbox` result cannot drift with it.
-        const taskNumbers = this.taskNumbers(request.workspaceId);
+        const taskNumbers = new Map(workspaceIds.flatMap(workspaceId => [...this.taskNumbers(workspaceId)]));
         const items = [];
         const unreadThreads = new Set();
         for (const threadRef of this.inboxCandidateThreads(authorized.memberId)) {
@@ -1054,8 +1144,14 @@ export class AgentTeamLedger {
             const channelRef = this.channelRefForThread(thread.threadRef);
             if (channelRef === undefined)
                 continue;
-            if (this.state.channels.get(channelRef)?.workspaceId !== request.workspaceId)
+            const channel = this.state.channels.get(channelRef);
+            if (channel === undefined || !workspaceIds.includes(channel.workspaceId))
+                continue;
+            // Archived Channels do not exist on Team API surfaces: their Threads
+            // reach neither Inbox slice, matching ref resolution and the feed.
+            if (channel.state === 'archived')
                 continue;
+            const workspaceId = channel.workspaceId;
             if (authorized.kind === 'member' && !this.isChannelMember(channelRef, authorized.memberId))
                 continue;
             const unread = this.unreadFor(authorized.memberId, thread.threadRef);
@@ -1070,7 +1166,7 @@ export class AgentTeamLedger {
             // observe a different commit between the two reads.
             const newest = unread.at(-1).fact;
             const taskNumber = task === undefined ? undefined : taskNumbers.get(task.taskRef);
-            items.push(Object.freeze({ channelRef,
+            items.push(Object.freeze({ workspaceId, channelRef,
                 channelName: this.state.channels.get(channelRef)?.name ?? '',
                 ...(task === undefined ? {} : { task }), ...(taskNumber === undefined ? {} : { taskNumber }), thread,
                 unreadCount: unread.length, directCount,
@@ -1082,7 +1178,7 @@ export class AgentTeamLedger {
         items.sort((left, right) => right.directCount - left.directCount || right.newestSequence - left.newestSequence || left.thread.threadRef.localeCompare(right.thread.threadRef));
         const selected = items.slice(0, limit);
         const recent = authorized.kind === 'human'
-            ? this.recentInboxItems(authorized.memberId, request.workspaceId, unreadThreads, taskNumbers)
+            ? this.recentInboxItems(authorized.memberId, workspaceIds[0], unreadThreads, taskNumbers)
             : Object.freeze([]);
         return Object.freeze({ items: Object.freeze(selected), recent,
             totalUnreadCount: items.reduce((sum, item) => sum + item.unreadCount, 0),
@@ -1147,7 +1243,12 @@ export class AgentTeamLedger {
             const channelRef = this.channelRefForThread(thread.threadRef);
             if (channelRef === undefined)
                 continue;
-            if (this.state.channels.get(channelRef)?.workspaceId !== workspaceId)
+            const channel = this.state.channels.get(channelRef);
+            if (channel === undefined || channel.workspaceId !== workspaceId)
+                continue;
+            // Archived Channels do not exist on Team API surfaces, so their Threads
+            // are no way back into work either — participation ends at archival.
+            if (channel.state === 'archived')
                 continue;
             const facts = this.state.factsByThread.get(thread.threadRef) ?? [];
             const newest = facts.at(-1);
@@ -1155,7 +1256,7 @@ export class AgentTeamLedger {
                 continue;
             const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
             const taskNumber = task === undefined ? undefined : taskNumbers.get(task.taskRef);
-            recent.push(Object.freeze({ channelRef,
+            recent.push(Object.freeze({ workspaceId, channelRef,
                 channelName: this.state.channels.get(channelRef)?.name ?? '',
                 ...(task === undefined ? {} : { task }), ...(taskNumber === undefined ? {} : { taskNumber }), thread,
                 unreadCount: 0, directCount: 0,
@@ -1183,9 +1284,10 @@ export class AgentTeamLedger {
     /** Model-visible notification material derived from the recipient's current durable unread state. */
     notificationFacts(memberId, request) {
         const member = this.requireMember(memberId);
-        if (member.workspaceId !== request.workspaceId)
+        if (request !== undefined && !this.participatesIn(memberId, request.workspaceId))
             throw new Error('Member cannot inspect another Workspace');
-        const inbox = this.inbox({ kind: 'member', memberId, handle: member.handle }, request);
+        const actor = { kind: 'member', memberId, handle: member.handle };
+        const inbox = request === undefined ? this.memberInbox(actor, {}) : this.inbox(actor, request);
         return Object.freeze(inbox.items.map(item => Object.freeze({ item,
             facts: this.unreadFor(memberId, item.thread.threadRef) })));
     }
@@ -1307,7 +1409,7 @@ export class AgentTeamLedger {
             throw new Error('cursor must be a non-negative integer sequence');
         if (memberId !== undefined) {
             const member = this.requireMember(memberId);
-            if (member.workspaceId !== request.workspaceId)
+            if (!this.participatesIn(member.memberId, request.workspaceId))
                 throw new Error('Member cannot view another Workspace');
         }
         if (request.channelRef !== undefined) {
@@ -1390,6 +1492,7 @@ export class AgentTeamLedger {
             const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
             const facts = this.state.factsByThread.get(thread.threadRef) ?? [];
             return Object.freeze({ message, mentions: fact.mentions, ...(task === undefined ? {} : { task, taskNumber: taskNumbers.get(task.taskRef) ?? 0 }), thread,
+                claimOwners: this.liveClaimOwners(task),
                 messageCount: this.state.messageCountByThread.get(thread.threadRef) ?? 0,
                 lastActivityAt: facts.at(-1)?.occurredAt ?? '' });
         });
@@ -1397,6 +1500,8 @@ export class AgentTeamLedger {
         const nextCursor = selected.length === 0 ? cursor : direction === 'before' ? selected[0].sequence : selected.at(-1).sequence;
         return Object.freeze({
             humanMemberId: initialization.data.humanMemberId,
+            workspaces: Object.freeze(memberId === undefined ? [] : this.workspacesOfFrom(this.state, memberId)
+                .map(workspaceId => Object.freeze({ workspaceId, default: workspaceId === this.state.members.get(memberId)?.workspaceId }))),
             channels: Object.freeze(channels),
             members: Object.freeze([...this.state.memberships.entries()].filter(([channelRef]) => channelRefs.has(channelRef)).flatMap(([channelRef, ids]) => [...ids].filter(id => {
                 const state = this.state.members.get(id)?.state;
@@ -1475,6 +1580,10 @@ export class AgentTeamLedger {
         }
         return scopes;
     }
+    /** One workspace change scope per Workspace the Member participates in — member-level commits wake every panel that lists it. */
+    memberWorkspaceScopes(memberId) {
+        return [...(this.state.participations.get(memberId) ?? [])].map(workspaceId => ({ kind: 'workspace', workspaceId }));
+    }
     /**
      * Durable position of the newest shared-projection commit: the version every
      * change waiter outside the presence scope observes. It only moves when a
@@ -1503,9 +1612,13 @@ export class AgentTeamLedger {
             case 'team/member-session-rolled-over':
             case 'team/member-updated':
             case 'team/member-removed':
-                return [{ kind: 'workspace', workspaceId: operation.data.member.workspaceId }];
+                return this.memberWorkspaceScopes(operation.data.member.memberId);
             case 'team/member-archived':
-                return this.withReleasedActivityScopes([{ kind: 'workspace', workspaceId: operation.data.member.workspaceId }], operation.data.tasks, operation.data.activities);
+                return this.withReleasedActivityScopes(this.memberWorkspaceScopes(operation.data.member.memberId), operation.data.tasks, operation.data.activities);
+            case 'team/member-workspace-joined':
+                return [{ kind: 'workspace', workspaceId: operation.data.workspaceId }];
+            case 'team/member-workspace-left':
+                return this.withReleasedActivityScopes([{ kind: 'workspace', workspaceId: operation.data.workspaceId }], operation.data.tasks, operation.data.activities);
             case 'team/channel-member-added':
                 return [{ kind: 'workspace', workspaceId: operation.data.workspaceId }, { kind: 'channel', channelRef: operation.data.channelRef }];
             case 'team/channel-member-removed':
@@ -1568,6 +1681,8 @@ export class AgentTeamLedger {
             for (const follower of this.state.attentionByThread.get(threadRef) ?? [])
                 members.add(follower);
         }
+        if (operation.kind === 'team/member-workspace-joined' || operation.kind === 'team/member-workspace-left')
+            members.add(operation.data.memberId);
         if (operation.actor.kind === 'member')
             members.add(operation.actor.memberId);
         return [...members];
@@ -1589,11 +1704,13 @@ export class AgentTeamLedger {
             case 'team/channel-archived':
             case 'team/member-removed':
             case 'team/member-archived':
+            case 'team/member-workspace-left':
                 return operation.data.activities.map(activity => activity.threadRef);
             case 'team/initialized':
             case 'team/channel-created':
             case 'team/channel-updated':
             case 'team/member-added':
+            case 'team/member-workspace-joined':
             case 'team/member-suspended':
             case 'team/member-resumed':
             case 'team/member-session-restarted':
@@ -1675,7 +1792,7 @@ export class AgentTeamLedger {
                 throw new Error('invalid initial Channel members');
             for (const memberId of memberIds) {
                 const member = projection.members.get(memberId);
-                if (member === undefined || member.workspaceId !== channel.workspaceId || member.state !== 'enabled')
+                if (member === undefined || !this.participatesInFrom(projection, member.memberId, channel.workspaceId) || member.state !== 'enabled')
                     throw new Error('invalid initial Channel Member');
             }
             return;
@@ -1773,10 +1890,10 @@ export class AgentTeamLedger {
                 || operation.data.member.presetId !== prior.presetId
                 || operation.data.member.privateMemoryPath !== prior.privateMemoryPath)
                 throw new Error('invalid Member update');
-            // The renamed handle must stay unique among the workspace's other live Members.
+            // The renamed handle must stay unique among the live Members sharing any Workspace participation.
             const normalized = operation.data.member.handle.normalize('NFKC').trim().toLowerCase();
             for (const other of projection.members.values()) {
-                if (other.memberId !== prior.memberId && other.state !== 'inactive' && other.workspaceId === prior.workspaceId
+                if (other.memberId !== prior.memberId && other.state !== 'inactive' && this.participationOverlapFrom(projection, other.memberId, prior.memberId)
                     && other.handle.normalize('NFKC').trim().toLowerCase() === normalized)
                     throw new Error('invalid Member update handle');
             }
@@ -1786,7 +1903,7 @@ export class AgentTeamLedger {
             assertHuman();
             const channel = projection.channels.get(operation.data.channelRef);
             const member = projection.members.get(operation.data.memberId);
-            if (channel === undefined || member === undefined || member.workspaceId !== channel.workspaceId || operation.data.workspaceId !== channel.workspaceId || projection.memberships.get(channel.channelRef)?.has(member.memberId))
+            if (channel === undefined || member === undefined || !this.participatesInFrom(projection, member.memberId, channel.workspaceId) || operation.data.workspaceId !== channel.workspaceId || projection.memberships.get(channel.channelRef)?.has(member.memberId))
                 throw new Error('invalid Channel membership');
             return;
         }
@@ -1795,12 +1912,32 @@ export class AgentTeamLedger {
             const channel = projection.channels.get(operation.data.channelRef);
             const member = projection.members.get(operation.data.memberId);
             if (channel === undefined || member === undefined || operation.data.workspaceId !== channel.workspaceId
-                || member.workspaceId !== channel.workspaceId || !projection.memberships.get(channel.channelRef)?.has(member.memberId))
+                || !this.participatesInFrom(projection, member.memberId, channel.workspaceId) || !projection.memberships.get(channel.channelRef)?.has(member.memberId))
                 throw new Error('invalid Channel membership removal');
             const threadRefs = new Set([...projection.threads.keys()].filter(threadRef => this.channelRefForThreadFrom(projection, threadRef) === channel.channelRef));
             this.validateReleaseCleanup(operation.data, projection, member.memberId, threadRefs, operation.sequence, refs);
             return;
         }
+        if (operation.kind === 'team/member-workspace-joined') {
+            assertHuman();
+            const member = projection.members.get(operation.data.memberId);
+            if (member === undefined || member.state === 'inactive' || member.state === 'archived'
+                || this.participatesInFrom(projection, member.memberId, operation.data.workspaceId))
+                throw new Error('invalid Workspace join');
+            this.assertHandleAvailableFrom(projection, operation.data.workspaceId, member.handle);
+            return;
+        }
+        if (operation.kind === 'team/member-workspace-left') {
+            assertHuman();
+            const member = projection.members.get(operation.data.memberId);
+            if (member === undefined || member.state === 'inactive' || member.state === 'archived'
+                || operation.data.workspaceId === member.workspaceId
+                || !this.participatesInFrom(projection, member.memberId, operation.data.workspaceId))
+                throw new Error('invalid Workspace leave');
+            const threadRefs = this.workspaceThreadRefsFrom(projection, operation.data.workspaceId);
+            this.validateReleaseCleanup(operation.data, projection, member.memberId, threadRefs, operation.sequence, refs);
+            return;
+        }
         if (operation.kind === 'team/channel-archived') {
             assertHuman();
             const prior = projection.channels.get(operation.data.channel.channelRef);
@@ -2062,7 +2199,7 @@ export class AgentTeamLedger {
         if (operation.kind === 'team/dm-sent') {
             const sender = assertMember();
             const recipient = projection.members.get(operation.data.recipientMemberId);
-            if (recipient === undefined || recipient.workspaceId !== operation.data.workspaceId
+            if (recipient === undefined || !this.participatesInFrom(projection, recipient.memberId, operation.data.workspaceId)
                 || recipient.state !== 'enabled' || recipient.memberId === AGENT_TEAM_HUMAN_MEMBER_ID
                 || operation.data.senderMemberId !== sender.memberId
                 || operation.data.recipientMemberId === sender.memberId
@@ -2253,8 +2390,9 @@ export class AgentTeamLedger {
         if (memberId === AGENT_TEAM_HUMAN_MEMBER_ID)
             return true;
         const member = projection.members.get(memberId);
+        const channelWorkspaceId = projection.channels.get(channelRef)?.workspaceId;
         return member !== undefined && member.state !== 'inactive' && member.state !== 'archived'
-            && projection.channels.get(channelRef)?.workspaceId === member.workspaceId
+            && channelWorkspaceId !== undefined && this.participatesInFrom(projection, memberId, channelWorkspaceId)
             && this.isChannelMemberFrom(projection, channelRef, memberId);
     }
     apply(operation) {
@@ -2279,6 +2417,9 @@ export class AgentTeamLedger {
         }
         if (operation.kind === 'team/member-added') {
             target.members.set(operation.data.member.memberId, operation.data.member);
+            // Creation seeds the first Workspace participation; member.workspaceId
+            // stays the default Workspace the Session roots in, immutable after add.
+            target.participations.set(operation.data.member.memberId, new Set([operation.data.member.workspaceId]));
             for (const channelRef of operation.data.channelRefs)
                 this.addMembership(target, channelRef, operation.data.member.memberId);
             return;
@@ -2337,6 +2478,23 @@ export class AgentTeamLedger {
             this.applyReleaseSnapshot(target, operation, operation.data, operation.occurredAt);
             return;
         }
+        if (operation.kind === 'team/member-workspace-joined') {
+            const workspaces = target.participations.get(operation.data.memberId) ?? new Set();
+            workspaces.add(operation.data.workspaceId);
+            target.participations.set(operation.data.memberId, workspaces);
+            return;
+        }
+        if (operation.kind === 'team/member-workspace-left') {
+            target.participations.get(operation.data.memberId)?.delete(operation.data.workspaceId);
+            // Departure ends Channel memberships inside the left Workspace — unlike
+            // archival, which keeps them hidden for a possible restore.
+            for (const channel of target.channels.values()) {
+                if (channel.workspaceId === operation.data.workspaceId)
+                    target.memberships.get(channel.channelRef)?.delete(operation.data.memberId);
+            }
+            this.applyReleaseSnapshot(target, operation, operation.data, operation.occurredAt);
+            return;
+        }
         if (operation.kind === 'team/channel-archived') {
             // Archival keeps Memberships: hidden state, not departure — a future
             // restore returns every Member to the Channel. Visibility filters by
@@ -2898,7 +3056,7 @@ export class AgentTeamLedger {
             if (memberId === AGENT_TEAM_HUMAN_MEMBER_ID)
                 continue;
             const member = this.requireMember(memberId);
-            if (member.state === 'inactive' || member.state === 'archived' || member.workspaceId !== channel.workspaceId || !this.isChannelMember(channel.channelRef, memberId)) {
+            if (member.state === 'inactive' || member.state === 'archived' || !this.participatesIn(member.memberId, channel.workspaceId) || !this.isChannelMember(channel.channelRef, memberId)) {
                 throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${channel.channelRef}'`);
             }
         }
@@ -3043,7 +3201,7 @@ export class AgentTeamLedger {
             return actor;
         }
         const member = this.assertMemberActor(actor);
-        if (member.workspaceId !== workspaceId)
+        if (!this.participatesIn(member.memberId, workspaceId))
             throw new Error('Member cannot mutate another Workspace');
         return actor;
     }
@@ -3220,10 +3378,50 @@ export class AgentTeamLedger {
     channelThreadRefsFrom(projection, channelRef) {
         return new Set([...projection.threads.keys()].filter(threadRef => this.channelRefForThreadFrom(projection, threadRef) === channelRef));
     }
+    /** The Workspace authorization question: does this Member participate in this Workspace. */
+    participatesIn(memberId, workspaceId) {
+        return this.participatesInFrom(this.state, memberId, workspaceId);
+    }
+    participatesInFrom(projection, memberId, workspaceId) {
+        return projection.participations.get(memberId)?.has(workspaceId) === true;
+    }
+    /** Every Workspace the Member participates in: the default first, then the rest sorted. */
+    workspacesOf(memberId) {
+        return Object.freeze(this.workspacesOfFrom(this.state, memberId));
+    }
+    workspacesOfFrom(projection, memberId) {
+        const member = projection.members.get(memberId);
+        if (member === undefined)
+            return [];
+        const rest = [...(projection.participations.get(memberId) ?? new Set())]
+            .filter(workspaceId => workspaceId !== member.workspaceId).sort();
+        return [member.workspaceId, ...rest];
+    }
+    /** Whether two Members share at least one Workspace participation — the handle-uniqueness scope. */
+    participationOverlapFrom(projection, leftMemberId, rightMemberId) {
+        const left = projection.participations.get(leftMemberId);
+        const right = projection.participations.get(rightMemberId);
+        if (left === undefined || right === undefined)
+            return false;
+        for (const workspaceId of left)
+            if (right.has(workspaceId))
+                return true;
+        return false;
+    }
+    /** Every Thread in the Workspace — the scope a Workspace leave replays its cleanup against. */
+    workspaceThreadRefs(workspaceId) {
+        return this.workspaceThreadRefsFrom(this.state, workspaceId);
+    }
+    workspaceThreadRefsFrom(projection, workspaceId) {
+        return new Set([...projection.threads.keys()].filter(threadRef => {
+            const channelRef = this.channelRefForThreadFrom(projection, threadRef);
+            return channelRef !== undefined && projection.channels.get(channelRef)?.workspaceId === workspaceId;
+        }));
+    }
     assertJoinableMember(workspaceId, memberId) {
         const member = this.requireMember(memberId);
-        if (member.workspaceId !== workspaceId)
-            throw new Error(`Agent Member '${memberId}' does not belong to Workspace '${workspaceId}'`);
+        if (!this.participatesIn(memberId, workspaceId))
+            throw new Error(`Agent Member '${memberId}' does not participate in Workspace '${workspaceId}'`);
         if (member.state !== 'enabled')
             throw new Error(`Agent Member '${memberId}' is ${member.state}; only enabled Members can join a Channel`);
     }
@@ -3305,9 +3503,12 @@ export class AgentTeamLedger {
         return direction.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
     }
     assertHandleAvailable(workspaceId, handle, exceptMemberId) {
+        this.assertHandleAvailableFrom(this.state, workspaceId, handle, exceptMemberId);
+    }
+    assertHandleAvailableFrom(projection, workspaceId, handle, exceptMemberId) {
         const normalized = handle.normalize('NFKC').trim().toLowerCase();
-        if ([...this.state.members.values()].some(member => member.memberId !== exceptMemberId && member.state !== 'inactive'
-            && member.workspaceId === workspaceId
+        if ([...projection.members.values()].some(member => member.memberId !== exceptMemberId && member.state !== 'inactive'
+            && this.participatesInFrom(projection, member.memberId, workspaceId)
             && member.handle.normalize('NFKC').trim().toLowerCase() === normalized)) {
             throw new Error(`Agent Member handle '${handle}' is already active in Workspace '${workspaceId}'`);
         }
@@ -3409,6 +3610,16 @@ export class AgentTeamLedger {
             || operation.data.workspaceId !== request.workspaceId || operation.data.channelRef !== request.channelRef || operation.data.memberId !== request.memberId)
             this.throwRequestCollision(request.requestId);
     }
+    assertSameWorkspaceJoin(operation, request) {
+        if (operation.kind !== 'team/member-workspace-joined' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.workspaceId !== request.workspaceId || operation.data.memberId !== request.memberId)
+            this.throwRequestCollision(request.requestId);
+    }
+    assertSameWorkspaceLeave(operation, request) {
+        if (operation.kind !== 'team/member-workspace-left' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.workspaceId !== request.workspaceId || operation.data.memberId !== request.memberId)
+            this.throwRequestCollision(request.requestId);
+    }
     assertSameChannelArchival(operation, request) {
         if (operation.kind !== 'team/channel-archived' || !this.sameActor(operation.actor, request.actor)
             || operation.data.workspaceId !== request.workspaceId || operation.data.channel.channelRef !== request.channelRef)
@@ -3564,6 +3775,13 @@ export class AgentTeamLedger {
         return Object.freeze({ receipt: this.receipt(operation), channelRef: operation.data.channelRef, memberId: operation.data.memberId,
             releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
     }
+    workspaceJoinResult(operation) {
+        return Object.freeze({ receipt: this.receipt(operation), memberId: operation.data.memberId, workspaceId: operation.data.workspaceId });
+    }
+    workspaceLeaveResult(operation) {
+        return Object.freeze({ receipt: this.receipt(operation), memberId: operation.data.memberId, workspaceId: operation.data.workspaceId,
+            releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
+    }
     channelArchivalResult(operation) {
         return Object.freeze({ receipt: this.receipt(operation), channel: operation.data.channel,
             releasedClaims: operation.data.claims });

package/packages/agent-team/lib/member-context.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { memberMemoryDirectoryPath } from "./member-runtime.js";
@@ -33,7 +34,8 @@ export function apply(ctx) {
                 ? 'memory.md is absent; the private memory index is empty.'
                 : 'memory.md is currently unreadable; do not use any earlier private memory context.');
         }
-        const text = `${renderMemberIdentity(member)}\n\n${memory}`;
+        const workspaces = renderMemberWorkspaces(host.workspacesForAgent(agent));
+        const text = `${renderMemberIdentity(member)}\n\n${memory}${workspaces === '' ? '' : `\n\n${workspaces}`}`;
         const latestText = agent.session.surface.nodes.toReversed().flatMap(sequence => {
             // `nodes` are event identities (SessionSeq); snapshotEvents takes log
             // offsets. Re-entering through the validating constructor keeps the two
@@ -61,6 +63,21 @@ export function renderMemberIdentity(member) {
         ? `Team identity: you are @${member.handle}.`
         : `Team identity: you are @${member.handle} — ${member.description}`;
 }
+/** A current address list, not a copy of instructions from another checkout. */
+export function renderMemberWorkspaces(workspaces) {
+    if (workspaces.length <= 1)
+        return '';
+    return [
+        'Team Workspace participation — this list replaces all earlier participation context.',
+        ...workspaces.map(workspace => `${workspace.workspaceId}${workspace.default ? ' (default; Session cwd)' : ''}: ${workspace.path === undefined
+            ? 'Workspace path unavailable; ask @human before filesystem work.'
+            : `${JSON.stringify(workspace.path)}; instructions: ${JSON.stringify(join(workspace.path, 'AGENTS.md'))}`}`),
+        'Your single Session and cwd stay in the default Workspace. Joining another Workspace does not move them.',
+        'For filesystem work in another Workspace, use absolute paths (or an explicit command cwd). Before working there, read its AGENTS.md and applicable directory instructions yourself; their contents are not injected here.',
+        'Pass workspace explicitly to team_view, team_thread, team_message and team_claim. team_inbox is the cross-Workspace triage entry point.',
+        'If an instruction is ambiguous about which Workspace it concerns, ask @human before acting. Participation does not itself join Channels.',
+    ].join('\n');
+}
 /** The four private-memory paths plus the out-of-cwd warning; callers append their own sentence. */
 function memoryPathsBlock(privateMemoryPath) {
     return `Private memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nPrivate skills directory: ${privateMemoryPath}/skills\nThese paths are outside the Workspace cwd.`;

package/packages/agent-team/lib/member-runtime.js

@@ -311,7 +311,8 @@ export class MemberRuntime {
  * moved home) holds a sanitized target in ITS tree while the record still names
  * the real one. Renaming across trees would take a Member's whole private
  * memory out of its home — silently, since only the next session notices an
- * empty index. Such a source is left exactly where it is.
+ * empty index. Such a source is left exactly where it is, and only that
+ * refusal is reported back: every other outcome needs nothing from the caller.
  */
 async function migrateLegacyMemoryDirectory(legacyPath, path) {
     let legacy;
@@ -320,7 +321,7 @@ async function migrateLegacyMemoryDirectory(legacyPath, path) {
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            return 'absent';
+            return undefined;
         throw error;
     }
     if (!legacy.isDirectory())
@@ -329,14 +330,14 @@ async function migrateLegacyMemoryDirectory(legacyPath, path) {
         return 'refused-foreign-home';
     try {
         await stat(path);
-        return 'target-present'; // Sanitized directory already present: migration already done or a new install.
+        return undefined; // Sanitized directory already present: migration already done or a new install.
     }
     catch (error) {
         if (error.code !== 'ENOENT')
             throw error;
     }
     await rename(legacyPath, path);
-    return 'migrated';
+    return undefined;
 }
 /**
  * Whether one absolute path names a Member directory inside THIS process's