@wowyuarm/dsh-agent-team 0.1.12 → 0.1.13

package/README.md

@@ -59,6 +59,8 @@ dsh plugin --profile web add @wowyuarm/dsh-agent-team
 dsh web
 ```
 
+Do not start DSH from its source checkout (`pnpm dsh web`): source mode loads a second copy of the scope module, so every member reports `selected preset is not team-enabled`. Always start the compiled CLI.
+
 Agent Team is opt-in. Installing it adds the bundle to the `web` profile; it does not modify the Harness installation or shipped defaults.
 
 ### 3. Verify and try it

package/README.zh.md

@@ -59,6 +59,8 @@ dsh plugin --profile web add @wowyuarm/dsh-agent-team
 dsh web
 ```
 
+不要从 DSH 源码 checkout 启动（`pnpm dsh web`）：源码模式会加载第二份 scope 模块，所有成员都会报 `selected preset is not team-enabled`。请始终使用编译产物启动。
+
 Agent Team 是显式 opt-in 的。安装只会把 bundle 加入 `web` profile，不会修改 Harness 安装，也不会修改 shipped defaults。
 
 ### 3. 验证并开始使用

package/cordis.patch.yml

@@ -15,10 +15,14 @@
       name: '@deepseek-ai/dsh-invariants'
     - id: wowyuarm-agent-team-invariant
       name: '@wowyuarm/dsh-agent-team/invariant'
-    # Team ledger medium backend. A plain dependency of this bundle, mounted
-    # as an ordinary storage provider row beside the shipped JSON backend.
+    # Team ledger medium backend. Vendored under our own package name (see
+    # packages/agent-team/src/vendor/storage-sqlite/): DSH Desktop generation
+    # installers strip `@deepseek-ai/*` copies and resolve them from the host
+    # closure, which ships no sqlite backend — a loader row naming that
+    # package blocks boot (GitHub issue #28). Mounted here as an ordinary
+    # storage provider row beside the shipped JSON backend.
     - id: storage-sqlite
-      name: '@deepseek-ai/dsh-storage-sqlite'
+      name: '@wowyuarm/dsh-agent-team/sqlite-backend'
       config:
         path: !!js dshHomePath('storages', 'agent_team.sqlite')
 

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@wowyuarm/dsh-agent-team",
-  "version": "0.1.12",
+  "version": "0.1.13",
+  "license": "MIT",
   "description": "A persistent agent team for long-running collaboration in DeepSeek Harness",
   "repository": {
     "type": "git",
@@ -41,6 +42,9 @@
     },
     "client": {
       "platform": "web",
+      "external": [
+        "@deepseek-ai/dsh-api-gateway/client"
+      ],
       "inject": [
         "@deepseek-ai/dsh-api-remotes",
         "@deepseek-ai/dsh-client-ui-sidebar",
@@ -54,10 +58,10 @@
     }
   },
   "dependencies": {
-    "@deepseek-ai/dsh-storage-sqlite": ">=0.1.5-rc.1 <0.2.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@deepseek-ai/dsh-storage-sqlite": "0.1.5-rc.2",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^24.0.0",
@@ -105,6 +109,10 @@
       "types": "./packages/agent-team/lib/types/preset-roster.d.ts",
       "default": "./packages/agent-team/lib/preset-roster.js"
     },
+    "./sqlite-backend": {
+      "types": "./packages/agent-team/lib/types/vendor/storage-sqlite/index.d.ts",
+      "default": "./packages/agent-team/lib/vendor/storage-sqlite/index.js"
+    },
     "./member-context": {
       "types": "./packages/agent-team/lib/types/member-context.d.ts",
       "default": "./packages/agent-team/lib/member-context.js"
@@ -117,6 +125,10 @@
       "types": "./packages/agent-team/lib/types/time-format.d.ts",
       "default": "./packages/agent-team/lib/time-format.js"
     },
+    "./mentions": {
+      "types": "./packages/agent-team/lib/types/mentions.d.ts",
+      "default": "./packages/agent-team/lib/mentions.js"
+    },
     "./member-skills": {
       "types": "./packages/agent-team/lib/types/member-skills.d.ts",
       "default": "./packages/agent-team/lib/member-skills.js"

package/packages/agent-team/README.md

@@ -18,7 +18,7 @@ One durable record stores progress instead of the projection it reported. A `tea
 
 `storage-domain` validates every record at the durable read boundary and rejects a backend unit stamped with another version. The Team updates its projection only after `KvTable.put()` resolves. Its Fiber owns the Domain handle; disposal rejects new Service calls through Cordis removal, drains accepted Domain writes, and closes the backend unit before the name can reopen.
 
-Member creation commits one stable Member/session/Workspace/preset/private-memory identity before unpublished Agent setup. Setup mounts the selected preset and validates its marked `team_message` plus all eight Team tools before publication. Failure leaves only that Member unavailable. Suspend waits for the owned `AgentHandle` to stop; resume and Host remount restore the exact persisted session.
+Member creation commits one stable Member/session/Workspace/preset/private-memory identity before unpublished Agent setup. The creation Workspace is recorded as the Member's creation site; further Workspaces are joined and left through the participation operations (`team/member-workspace-joined`/`team/member-workspace-left`), which grant collaboration immediately without moving the Session. Setup mounts the selected preset and validates its marked `team_message` plus all eight Team tools before publication. Failure leaves only that Member unavailable. Suspend waits for the owned `AgentHandle` to stop; resume and Host remount restore the exact persisted session.
 
 Archival is the reversible third state between suspend and remove, for Members and Channels alike. `archiveMember` commits `team/member-archived`, disposes the live session while keeping private memory and the Session log on disk, archives the Session from grouping surfaces, and releases the Member's active Claims with public `claims_released` Activities plus Attention/marker cleanup. `archiveChannel` commits `team/channel-archived` with the same release shape across every owner on the Channel's Threads. Memberships survive both forms — hidden state, not departure. Archived entities are gone from every Team API surface: projections, ref resolution (their Task refs stop resolving, so message bodies render plain text), and ref-addressed reads (`readThread`/`threadHistory`/`threadObservations`/`listClaims` reject with an explicit archived error) — while the facts stay complete in the ledger for replay and a future restore; that boundary is the archival-vs-remove divide. Removal from archived stays available as the data hygiene path; there is no restore entry point yet (mirroring archived dsh sessions).
 
@@ -34,7 +34,7 @@ Adding a Member to a Channel grants future read/send/claim authority but injects
 
 Member replies require the exact current Thread revision and atomically update Message and Thread facts. `threadRef` is the primary collaboration identity; released task-only Clients may send a Host-resolved `taskRef` alias for taskful Threads, while Task/Claim operations remain Task-ref based. Unread work must be read before a mutation; stale revisions are rejected after that unread gate. A closed Task rejects replies and new Attention; reopening restores the Task without restoring prior Attention. Taskless Threads still support replies, follow, mentions, Inbox, read, and history, but have no Claims or Task-resolution path. Top-level Messages may mention Agents directly: mentioned Members start following the new Thread. In an existing Thread, a Human reply mentioning a Member that is not currently following requires a process-local, one-use confirmation token before the operation commits, while such a Member reply commits and delivers only to Members the Thread has ever carried, reporting the rest as undelivered. Mentions are authored in the Message body as `@Handle` and resolved by the Host against the Channel's addressable names; Message facts carry the resolved refs, and the Client renders mention chips only for those Members. Claim/done/release and Task changes are ordered host-authored Activities. Active Claims exclude only the same normalized Direction; different Directions can run concurrently. Task state is derived from Claims unless Human acceptance or closure overrides it. Close releases active Claims and clears Thread Attention atomically. Member removal marks the member inactive, releases owned active Claims, clears its Attention and direct markers, and archives the session after the durable commit. Message and Activity facts share one bounded sequence cursor.
 
-`changes()` is the Client invalidation stream. Each request declares one optional `scope` — workspace, channel, or thread — plus an abortable transport signal; a committed operation wakes only waiters whose scope matches the scopes derived from that operation (member lifecycle and presence wake their Workspace; content operations wake their Channel and Thread). A Thread read derives no scope, because it advances only the reader's private watermark — and a read that finds nothing unread for its reader (no watermark to advance, no marker to consume) appends no operation at all: it answers with the same projection-derived picture and no receipt, so an already-read Thread costs neither a durable write nor a replay. After each commit the Host notifies only the Members whose Inbox projection the operation can have changed — the operation's Attention/marker delta plus current followers of the touched Threads — never every live Agent.
+`changes({ scope? }, signal?)` returns an `AsyncIterable<{ version: number }>` through a streaming Remote. It emits the current baseline, then matching workspace/channel/thread/presence invalidations; omitting scope observes shared projections but not presence. A paused consumer retains only the latest pending version; cancellation or Host disposal closes the stream. The Client must reread projections on every baseline, even when the version is unchanged or lower after a restart. See [architecture](../../docs/architecture.md#host-authority) for scope/version and recovery semantics. Thread reads change only private read state: they wake no scope, and a read with no unread or markers to consume appends no operation. After a commit, Inbox hints are recomputed only for affected Members.
 
 M1 supports one Host writer. The ledger is permanent and has no snapshot or compaction path.
 

package/packages/agent-team/README.zh.md

@@ -18,7 +18,7 @@ Service 使用 `ctx.storageDomain`、`ctx.workspaceRegistry`、`ctx.agents`、`c
 
 `storage-domain` 在持久读取处校验每条 record，并拒绝被其他版本标记的 backend unit。Team 只在 `KvTable.put()` 完成后更新 projection。其 Fiber 持有 Domain handle；dispose 通过 Cordis 移除拒绝新的 Service 调用，排空已接受的 Domain write，并在名称可重新打开前关闭 backend unit。
 
-创建 Member 时，先提交稳定的 Member/session/Workspace/preset/private-memory 身份，再执行 unpublished Agent setup。Setup 挂载指定 preset，并在发布前检查带 marker 的 `team_message` 和全部八个 Team tools。失败只把该 Member 标为 unavailable。Suspend 等待所属 `AgentHandle` 完全停止；resume 和 Host remount 恢复同一个持久 session。
+创建 Member 时，先提交稳定的 Member/session/Workspace/preset/private-memory 身份，再执行 unpublished Agent setup。创建 Workspace 记录为 Member 的创建地；更多 Workspace 通过参与操作（`team/member-workspace-joined`/`team/member-workspace-left`）加入与退出——加入即获得协作能力，不移动 Session。Setup 挂载指定 preset，并在发布前检查带 marker 的 `team_message` 和全部八个 Team tools。失败只把该 Member 标为 unavailable。Suspend 等待所属 `AgentHandle` 完全停止；resume 和 Host remount 恢复同一个持久 session。
 
 归档（archival）是介于 suspend 与 remove 之间的可逆第三态，Member 与 Channel 通用。`archiveMember` 提交 `team/member-archived`，dispose 活跃 session（私有记忆与 Session log 留在磁盘），把 Session 从分组面归档，并释放该 Member 的活跃 Claim（公开 `claims_released` Activity + Attention/marker 清理）。`archiveChannel` 提交 `team/channel-archived`，对该频道全部 Threads 上所有 owner 做同样的释放。两种归档都保留 Memberships——是隐藏而非离开。归档实体在所有 Team API 面上"默认不存在"：投影、ref 解析（其 Task ref 不再解析，消息正文渲染为纯文本）、按 ref 的读取（`readThread`/`threadHistory`/`threadObservations`/`listClaims` 以明确的 archived 错误拒绝）——而事实在 ledger 中完整保留，供重放与未来恢复；这条边界正是归档与 remove 的分界。从归档态 remove 仍可用（数据卫生路径）；本轮有意不提供恢复入口（对齐 dsh session 归档现状）。
 
@@ -34,7 +34,7 @@ Skills 是 Member 私有的：preset 不带共享 skill-filesystem row，Host
 
 Member reply 必须携带准确的当前 Thread revision，并在一个 operation 内更新 Message 和 Thread facts。`threadRef` 是协作主身份；released task-only Client 可为 taskful Thread 传入 Host-resolved `taskRef` alias，而 Task/Claim 操作仍以 Task ref 为准。未读工作必须先 read；revision 过期时拒绝写入。Closed Task 拒绝 reply 和新的 Attention；reopen 恢复 Task，但不恢复之前的 Attention。taskless Thread 仍支持 reply、follow、mention、Inbox、read 和 history，但没有 Claim 或 Task resolution path。顶层消息可以直接 mention Agent：被 mention 的 Member 会开始关注新 Thread。在既有 Thread 中，Human 的 reply 提到当前未 follow 的 Member 时必须先取得 process-local one-use confirmation token 才提交 operation；Member 的此类 reply 会提交，但只送达该 Thread 曾经承载过的 Member，其余在结果里报告为未送达。mention 在 Message 正文里以 `@Handle` 撰写，由 Host 按 Channel 的可寻址名字解析；Message fact 携带解析后的 refs，Client 只为这些 Member 渲染 mention chip。claim/done/release 和 Task change 是有序的 host-authored Activity。Active Claim 只排斥相同的 normalized Direction；不同 Direction 可以并行。Task status 从 Claims 派生，Human accept/close 是覆盖事实。Close 原子释放 active Claims 并清除 Thread Attention。Member remove 原子标记 inactive、释放 owned active Claims、清除该成员的 Attention 和 direct markers，再归档 session。Message 与 Activity facts 共用一个有界 sequence cursor。
 
-`changes()` 是 Client 失效通知流。每个请求声明一个可选 `scope`（workspace、channel 或 thread）和可取消的传输 signal；一次提交的 operation 只唤醒 scope 与该 operation 派生范围匹配的 waiter（成员生命周期与 presence 唤醒其 Workspace，内容操作唤醒其 Channel 与 Thread）。Thread read 不派生任何 scope，因为它只推进读者自己的私有水位——而一次读如果对读者没有任何未读（没有水位可推进、没有 marker 可消费），就完全不追加 operation：它返回同一份由 projection 派生的画面且不带 receipt，所以已读完的 Thread 既不付一次持久写、也不付一次重放。每次提交后，Host 只通知 Inbox projection 可能被该 operation 改变的 Member——即 operation 的 Attention/marker delta 加上被触及 Thread 的当前关注者——而不是全部在线 Agent。
+`changes({ scope? }, signal?)` 通过流式 Remote 返回 `AsyncIterable<{ version: number }>`。先发送当前基线，之后发送匹配的 workspace/channel/thread/presence 通知；省略 scope 时观察共享投影，不包含 presence。消费者暂停期间只保留最新待发送版本；取消或 Host 释放时关闭流。Client 必须在每次基线到达时重读投影，即使重启后的版本相同或更低。scope、版本和恢复语义见[架构文档](../../docs/architecture.zh.md#host-authority)。Thread read 只改变私有已读状态，不唤醒任何 scope；没有未读或 marker 可消费时不追加 operation。提交后只为受影响的 Members 重算 Inbox hints。
 
 M1 支持单个 Host writer。Ledger 永久保留，不提供 snapshot 或 compaction。
 

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

@@ -178,6 +178,8 @@ let AgentTeam = (() => {
     let _promoteThread_decorators;
     let _joinChannel_decorators;
     let _removeChannelMember_decorators;
+    let _joinWorkspace_decorators;
+    let _leaveWorkspace_decorators;
     let _sendMessage_decorators;
     let _putAttachment_decorators;
     let _getAttachment_decorators;
@@ -193,7 +195,7 @@ let AgentTeam = (() => {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _resolveTaskRefs_decorators = [Remote('resolveTaskRefs')];
             _membersForClient_decorators = [Remote('members')];
-            _changes_decorators = [Remote('changes')];
+            _changes_decorators = [Remote({ mode: 'stream' })];
             _createChannel_decorators = [Remote('createChannel')];
             _updateChannel_decorators = [Remote('updateChannel')];
             _archiveChannel_decorators = [Remote('archiveChannel')];
@@ -206,6 +208,8 @@ let AgentTeam = (() => {
             _promoteThread_decorators = [Remote('promoteThread')];
             _joinChannel_decorators = [Remote('joinChannel')];
             _removeChannelMember_decorators = [Remote('removeChannelMember')];
+            _joinWorkspace_decorators = [Remote('joinWorkspace')];
+            _leaveWorkspace_decorators = [Remote('leaveWorkspace')];
             _sendMessage_decorators = [Remote('sendMessage')];
             _putAttachment_decorators = [Remote('putAttachment')];
             _getAttachment_decorators = [Remote('getAttachment')];
@@ -231,6 +235,8 @@ let AgentTeam = (() => {
             __esDecorate(this, null, _promoteThread_decorators, { kind: "method", name: "promoteThread", static: false, private: false, access: { has: obj => "promoteThread" in obj, get: obj => obj.promoteThread }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _joinChannel_decorators, { kind: "method", name: "joinChannel", static: false, private: false, access: { has: obj => "joinChannel" in obj, get: obj => obj.joinChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _removeChannelMember_decorators, { kind: "method", name: "removeChannelMember", static: false, private: false, access: { has: obj => "removeChannelMember" in obj, get: obj => obj.removeChannelMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _joinWorkspace_decorators, { kind: "method", name: "joinWorkspace", static: false, private: false, access: { has: obj => "joinWorkspace" in obj, get: obj => obj.joinWorkspace }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _leaveWorkspace_decorators, { kind: "method", name: "leaveWorkspace", static: false, private: false, access: { has: obj => "leaveWorkspace" in obj, get: obj => obj.leaveWorkspace }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _sendMessage_decorators, { kind: "method", name: "sendMessage", static: false, private: false, access: { has: obj => "sendMessage" in obj, get: obj => obj.sendMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _putAttachment_decorators, { kind: "method", name: "putAttachment", static: false, private: false, access: { has: obj => "putAttachment" in obj, get: obj => obj.putAttachment }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getAttachment_decorators, { kind: "method", name: "getAttachment", static: false, private: false, access: { has: obj => "getAttachment" in obj, get: obj => obj.getAttachment }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -382,7 +388,7 @@ let AgentTeam = (() => {
                 if (kind !== undefined)
                     this.ctx.logger.warn(`agent-team: member '${member.handle}' hit a recoverable ${kind} error; recording a consecutive error occurrence`);
                 this.recovery.onError(member.memberId, message);
-                this.emitPresenceChanged(member.workspaceId);
+                this.emitMemberPresenceChanged(member);
             });
             this.ctx.on('agent/status', ({ agent, status }) => {
                 const member = this.memberForAgent(agent);
@@ -394,7 +400,7 @@ let AgentTeam = (() => {
                     const recovered = this.clearMemberFailure(member.memberId, 'runtime');
                     if (recovered)
                         this.notifiedInbox.delete(member.memberId);
-                    this.emitPresenceChanged(member.workspaceId);
+                    this.emitMemberPresenceChanged(member);
                     // A rollover/recovery in flight delivers its own sequenced
                     // rederived Inbox after the handoff and carried input; a status-driven
                     // steer here would claim the handoff turn's next step and leapfrog
@@ -411,7 +417,7 @@ let AgentTeam = (() => {
                     if (this.memberFailures.get(member.memberId)?.runtime === undefined) {
                         this.recovery.onCleanTurnEnd(member.memberId);
                     }
-                    this.emitPresenceChanged(member.workspaceId);
+                    this.emitMemberPresenceChanged(member);
                 }
             });
             // The store's dispatch carrier is untagged, so a scope-tagged listener
@@ -477,6 +483,7 @@ let AgentTeam = (() => {
             // One metadata listing serves every Member restore; per-member list calls
             // would repeat the same I/O linearly during startup.
             const persistedSessions = new Set((await this.persistedSessionHeaders()).map(snapshot => snapshot.header.id));
+            await this.sweepWorkspaceParticipations(ledger);
             for (const member of ledger.listMembers()) {
                 if (member.state === 'enabled')
                     await this.activateMember(member, undefined, persistedSessions);
@@ -484,6 +491,31 @@ let AgentTeam = (() => {
                     await this.memberRuntime.cleanupRemovedMember(member);
             }
         }
+        /**
+         * Lazy Workspace-deletion handling: a Workspace that no longer exists can
+         * only be detected through the registry — there is no deletion event. A
+         * dead non-default participation is withdrawn here (its Claims and
+         * Attention release through the normal leave path); a dead default
+         * Workspace is left alone — activation fails on its missing cwd and the
+         * Member surfaces as unavailable for Human attention.
+         */
+        async sweepWorkspaceParticipations(ledger) {
+            for (const member of ledger.listMembers()) {
+                if (member.state === 'inactive' || member.state === 'archived')
+                    continue;
+                for (const workspaceId of ledger.workspacesOf(member.memberId)) {
+                    if (workspaceId === member.workspaceId || this.ctx.workspaceRegistry.get(workspaceId) !== undefined)
+                        continue;
+                    this.ctx.logger.warn(`agent-team: workspace '${workspaceId}' is gone; withdrawing member '${member.handle}' from it`);
+                    try {
+                        await ledger.leaveWorkspace({ requestId: randomUUID(), workspaceId, memberId: member.memberId, actor: agentTeamHumanActor() });
+                    }
+                    catch (error) {
+                        this.ctx.logger.warn(`agent-team: failed to withdraw member '${member.handle}' from deleted workspace '${workspaceId}': ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+        }
         /**
          * Whether one Member Session has durable persisted content, decided through
          * {@link SessionPersistence.stat} rather than a bare metadata listing: the
@@ -519,56 +551,52 @@ let AgentTeam = (() => {
             });
             return Object.freeze({ resolved: Object.freeze(this.requireLedger().resolveTaskRefs(request.workspaceId, taskRefs)) });
         }
-        /** Return only this Workspace's current Member projection to the Client. */
+        /** Browser-safe Human roster, optionally filtered to one participation. */
         membersForClient(request) {
-            this.requireWorkspace(request.workspaceId);
+            if (request.workspaceId !== undefined)
+                this.requireWorkspace(request.workspaceId);
+            const ledger = this.requireLedger();
             return this.members()
-                .filter(status => status.member.workspaceId === request.workspaceId)
-                .map(({ member: { privateMemoryPath: _privateMemoryPath, ...member }, ...status }) => Object.freeze({ ...status, member: Object.freeze(member) }));
+                .filter(status => request.workspaceId === undefined || ledger.participatesIn(status.member.memberId, request.workspaceId))
+                .map(({ member: { privateMemoryPath: _privateMemoryPath, ...member }, ...status }) => Object.freeze({ ...status, member: Object.freeze(member), workspaceIds: ledger.workspacesOf(member.memberId) }));
         }
-        /** Wait for a lightweight projection invalidation without exposing ledger records. */
-        async changes(request, signal) {
-            if (!Number.isInteger(request.afterVersion) || request.afterVersion < 0)
-                throw new Error('afterVersion must be a non-negative integer');
+        /** Emit a current baseline, then coalesced invalidations until canceled. */
+        async *changes(request, signal) {
             const scope = this.validateChangeScope(request.scope);
-            const version = this.changeVersionOf(scope);
-            if (version > request.afterVersion || !this.accepting)
-                return Object.freeze({ version });
-            return new Promise((resolve, reject) => {
-                let settled = false;
-                const waiter = {
-                    scope,
-                    wake: version => {
-                        if (settled)
-                            return;
-                        settled = true;
-                        clearTimeout(timeout);
-                        signal?.removeEventListener('abort', onAbort);
-                        resolve(Object.freeze({ version }));
-                    },
-                };
-                const timeout = setTimeout(() => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    this.changeWaiters.delete(waiter);
-                    resolve(Object.freeze({ version: this.changeVersionOf(scope) }));
-                }, 25_000);
-                const onAbort = () => {
-                    if (settled)
+            let pending;
+            let resume;
+            const waiter = {
+                scope,
+                wake: version => {
+                    pending = version;
+                    resume?.();
+                },
+            };
+            const onAbort = () => { resume?.(); };
+            if (signal?.aborted || !this.accepting)
+                return;
+            this.changeWaiters.add(waiter);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+                // Listen before yielding so a commit during the consumer's read is kept.
+                yield { version: this.changeVersionOf(scope) };
+                while (!signal?.aborted && this.accepting) {
+                    if (pending === undefined)
+                        await new Promise(resolve => { resume = resolve; });
+                    resume = undefined;
+                    if (signal?.aborted || !this.accepting)
                         return;
-                    settled = true;
-                    clearTimeout(timeout);
-                    this.changeWaiters.delete(waiter);
-                    reject(new Error('changes wait was aborted'));
-                };
-                signal?.addEventListener('abort', onAbort, { once: true });
-                if (signal?.aborted === true) {
-                    onAbort();
-                    return;
+                    if (pending !== undefined) {
+                        const version = pending;
+                        pending = undefined;
+                        yield { version };
+                    }
                 }
-                this.changeWaiters.add(waiter);
-            });
+            }
+            finally {
+                this.changeWaiters.delete(waiter);
+                signal?.removeEventListener('abort', onAbort);
+            }
         }
         /** Return durable Team status without issuing a model request or a storage write. */
         status() {
@@ -672,7 +700,7 @@ let AgentTeam = (() => {
         async recoverMember(request) {
             this.requireAccepting();
             const member = this.requireLedger().getMember(request.memberId);
-            if (member === undefined || member.workspaceId !== request.workspaceId)
+            if (member === undefined || !this.requireLedger().participatesIn(request.memberId, request.workspaceId))
                 throw new Error(`unknown Member '${request.memberId}' in workspace '${request.workspaceId}'`);
             this.recovery.stopTracking(request.memberId);
             // An orphaned composition cannot be steered: its tools are gone, so a
@@ -730,7 +758,7 @@ let AgentTeam = (() => {
                 this.requireAccepting();
                 this.requireWorkspace(request.workspaceId);
                 const stored = this.requireLedger().getMember(request.memberId);
-                if (stored === undefined || stored.workspaceId !== request.workspaceId)
+                if (stored === undefined || !this.requireLedger().participatesIn(request.memberId, request.workspaceId))
                     throw new Error(`unknown Member '${request.memberId}' in workspace '${request.workspaceId}'`);
                 if (stored.state !== 'enabled')
                     throw new Error(`Agent Member '${stored.handle}' is ${stored.state}; only enabled Members can start from a new context`);
@@ -876,7 +904,7 @@ let AgentTeam = (() => {
                 reactivated.agent.steer(this.contextManagement.handoffMessageFor(plan));
                 for (const message of carriedInput)
                     reactivated.agent.followup(message);
-                const notifications = this.requireLedger().notificationFacts(memberId, { workspaceId: rolled.member.workspaceId });
+                const notifications = this.requireLedger().notificationFacts(rolled.member.memberId);
                 if (notifications.length > 0)
                     this.notifyMember(reactivated.agent, carriedInput.length > 0);
             });
@@ -914,7 +942,7 @@ let AgentTeam = (() => {
             const handle = this.handles.get(member.memberId);
             if (handle === undefined)
                 throw new Error(`member '${member.handle}' has no active session`);
-            const notifications = this.requireLedger().notificationFacts(member.memberId, { workspaceId: member.workspaceId });
+            const notifications = this.requireLedger().notificationFacts(member.memberId);
             const body = notifications.length === 0 ? text : `${text}\n\n${this.notificationText(notifications, member.memberId)}`;
             const hint = createUserMessage({
                 content: [{ type: 'text', text: body }],
@@ -1045,6 +1073,22 @@ let AgentTeam = (() => {
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
+        /** Human-only Workspace participation grant; a pure relation — no Session moves. */
+        async joinWorkspace(request) {
+            const actor = this.humanCall(request.workspaceId);
+            const result = await this.requireLedger().joinWorkspace({ ...request, actor });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        /** Human-only Workspace participation withdrawal and Workspace-scoped cleanup. */
+        async leaveWorkspace(request) {
+            const actor = this.humanCall(request.workspaceId);
+            const result = await this.requireLedger().leaveWorkspace({ ...request, actor });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
         /** Human top-level Thread start; asTask attaches an optional Task overlay. */
         async sendMessage(request) {
             return this.sendMessageAs(this.humanCall(request.workspaceId), request);
@@ -1185,8 +1229,10 @@ let AgentTeam = (() => {
         }
         inboxForAgent(agent, request) {
             const actor = this.memberActor(agent);
+            if (request.workspaceId === undefined)
+                return this.requireLedger().memberInbox(actor, request);
             this.requireAgentWorkspace(actor, request.workspaceId);
-            return this.requireLedger().inbox(actor, request);
+            return this.requireLedger().inbox(actor, { ...request, workspaceId: request.workspaceId });
         }
         async readThreadForAgent(agent, request) {
             const actor = this.memberCall(agent, request.workspaceId);
@@ -1270,7 +1316,7 @@ let AgentTeam = (() => {
             }
             try {
                 const message = createUserMessage({
-                    content: [{ type: 'text', text: this.dmRelayText(agent, recipient, request.body.trim(), result.value.receipt.occurredAt, result.value.receipt.operationId) }],
+                    content: [{ type: 'text', text: this.dmRelayText(agent, recipient, request.body.trim(), result.value.receipt.occurredAt, result.value.receipt.operationId, request.workspaceId) }],
                     source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'relay' },
                 });
                 // An idle recipient gets one ordinary turn; a busy one is steered into
@@ -1286,26 +1332,38 @@ let AgentTeam = (() => {
             return result.value;
         }
         /** Relay body: the DM itself plus one bounded line of adjacent context. */
-        dmRelayText(senderAgent, recipient, body, occurredAt, excluding) {
+        dmRelayText(senderAgent, recipient, body, occurredAt, excluding, workspaceId) {
             const sender = this.memberForAgent(senderAgent);
             const prior = this.requireLedger().dmHistoryBetween(senderAgent.id, recipient.memberId, excluding);
             const header = `Direct message from @${sender?.handle ?? 'a Team Member'} at ${formatTeamTimestamp(occurredAt)}:`;
             const context = prior === undefined ? '' : `\n\n[most recent prior DM between you: ${prior}]`;
-            return `${header}\n\n${body}${context}`;
+            return `${header}\nWorkspace: ${workspaceId}\n\n${body}${context}`;
         }
         threadHistoryForAgent(agent, request) {
             const actor = this.memberActor(agent);
             this.requireAgentWorkspace(actor, request.workspaceId);
             return this.requireLedger().threadHistory(actor, request);
         }
-        /** Agent-only bounded discovery projection. */
+        /** Live participation addresses; paths remain owned by the Harness registry. */
+        workspacesForAgent(agent) {
+            const actor = this.memberActor(agent);
+            const member = this.requireLedger().getMember(actor.memberId);
+            return Object.freeze(this.requireLedger().workspacesOf(actor.memberId).map(workspaceId => Object.freeze({
+                workspaceId, path: this.ctx.workspaceRegistry.get(workspaceId)?.path, default: workspaceId === member.workspaceId,
+            })));
+        }
+        /** Agent-only bounded discovery projection; participation list carries registry titles when known. */
         viewForAgent(agent, request) {
             const member = this.memberForAgent(agent);
             if (member === undefined)
                 throw new Error('Agent is not an active Team Member');
-            if (member.workspaceId !== request.workspaceId)
+            if (!this.requireLedger().participatesIn(member.memberId, request.workspaceId))
                 throw new Error('Member cannot view another Workspace');
-            return this.requireLedger().view(request, member.memberId);
+            const view = this.requireLedger().view(request, member.memberId);
+            return Object.freeze({ ...view, workspaces: Object.freeze(view.workspaces.map(participation => {
+                    const title = this.ctx.workspaceRegistry.get(participation.workspaceId)?.title;
+                    return title === undefined ? participation : Object.freeze({ ...participation, title });
+                })) });
         }
         /** Validate the durable ledger against an independently replayed projection. */
         validateLedger() {
@@ -2040,9 +2098,10 @@ let AgentTeam = (() => {
             this.requireWorkspace(workspaceId);
             return agentTeamHumanActor();
         }
-        /** Fence one Member call: accepting Host, live Member binding, matching Workspace. */
+        /** Fence one Member call: accepting Host, live Member binding, matching Workspace participation. */
         memberCall(agent, workspaceId) {
             this.requireAccepting();
+            this.requireWorkspace(workspaceId);
             const actor = this.memberActor(agent);
             this.requireAgentWorkspace(actor, workspaceId);
             return actor;
@@ -2054,7 +2113,7 @@ let AgentTeam = (() => {
             return Object.freeze({ kind: 'member', memberId: member.memberId, handle: member.handle });
         }
         requireAgentWorkspace(actor, workspaceId) {
-            if (this.requireLedger().getMember(actor.memberId)?.workspaceId !== workspaceId)
+            if (!this.requireLedger().participatesIn(actor.memberId, workspaceId))
                 throw new Error('Member cannot mutate another Workspace');
         }
         /**
@@ -2313,7 +2372,7 @@ let AgentTeam = (() => {
             }
             finally {
                 // Activation only changes this Workspace's presence projection.
-                this.emitPresenceChanged(member.workspaceId);
+                this.emitMemberPresenceChanged(member);
             }
         }
         /**
@@ -2486,6 +2545,25 @@ let AgentTeam = (() => {
             }
             const ledger = this.requireLedger();
             this.emitChanged(ledger.changeScopesOf(operation));
+            if (operation.kind === 'team/member-workspace-joined' || operation.kind === 'team/member-workspace-left') {
+                const agent = this.handles.get(operation.data.memberId)?.agent;
+                if (agent !== undefined) {
+                    const path = this.ctx.workspaceRegistry.get(operation.data.workspaceId)?.path;
+                    const text = `Team participation changed: you have ${operation.kind === 'team/member-workspace-joined' ? 'joined' : 'left'} Workspace ${operation.data.workspaceId}${path === undefined ? ' (path unavailable)' : ` (${JSON.stringify(path)})`}.\nCurrent Workspace ids: ${ledger.workspacesOf(operation.data.memberId).join(', ')}. This replaces earlier participation information. Your Session and cwd have not moved.`;
+                    const notice = createUserMessage({ content: [{ type: 'text', text }],
+                        source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: 'Team Workspace participation changed' } });
+                    try {
+                        if (agent.status === 'idle' || agent.inbox.nextTurn.some(message => message.source.kind === 'user'))
+                            agent.followup(notice);
+                        else
+                            agent.steer(notice);
+                    }
+                    catch (error) {
+                        // Notification delivery cannot roll back a committed participation.
+                        this.ctx.logger.warn(`agent-team: participation notice not delivered: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
             for (const memberId of ledger.affectedMembersOf(operation)) {
                 const handle = this.handles.get(memberId);
                 if (handle !== undefined)
@@ -2521,10 +2599,8 @@ let AgentTeam = (() => {
                 .map((job) => `${job.name ?? job.id}`);
         }
         emitAutoCompactionChanged(memberId) {
-            const workspaceId = this.ledger?.getMember(memberId)?.workspaceId;
-            if (workspaceId === undefined)
-                return;
-            this.emitPresenceChanged(workspaceId);
+            for (const workspaceId of this.ledger?.workspacesOf(memberId) ?? [])
+                this.emitPresenceChanged(workspaceId);
         }
         /**
          * Presence-only invalidation: Agent running/idle/activation/failure changes
@@ -2534,12 +2610,17 @@ let AgentTeam = (() => {
         emitPresenceChanged(workspaceId) {
             this.emitChanged([{ kind: 'presence', workspaceId }]);
         }
+        /** Presence invalidation in every Workspace the Member participates in — each panel listing it must refresh. */
+        emitMemberPresenceChanged(member) {
+            for (const workspaceId of this.requireLedger().workspacesOf(member.memberId))
+                this.emitPresenceChanged(workspaceId);
+        }
         /** Wake from durable unread state with bounded facts for direct and state-changing work. */
         notifyMember(agent, sequenced = false) {
             const member = this.memberForAgent(agent);
             if (member === undefined || member.state !== 'enabled')
                 return;
-            const notifications = this.requireLedger().notificationFacts(member.memberId, { workspaceId: member.workspaceId });
+            const notifications = this.requireLedger().notificationFacts(member.memberId);
             if (notifications.length === 0) {
                 this.notifiedInbox.delete(member.memberId);
                 return;
@@ -2612,6 +2693,8 @@ let AgentTeam = (() => {
                 return true;
             };
             for (const { item, facts } of notifications.slice(0, 8)) {
+                if (!append(`Workspace: ${item.workspaceId}\nChannel: ${item.channelRef}`))
+                    break;
                 for (const { fact, direct } of facts) {
                     if (detailedFactCount >= 20) {
                         omitted = true;
@@ -2641,7 +2724,7 @@ let AgentTeam = (() => {
             }
             if (omitted)
                 sections.push('More unread work remains in team_inbox; the automatic context is bounded.');
-            sections.push('Use team_thread read with the relevant threadRef before acting or replying. Use team_inbox only when you need to triage the remaining Threads.');
+            sections.push('Use team_thread read with the relevant workspace and threadRef before acting or replying. Use team_inbox only when you need to triage the remaining Threads.');
             return sections.join('\n\n');
         }
         boundedNotificationBody(body) {
@@ -2731,7 +2814,6 @@ let AgentTeam = (() => {
                 const waiterScope = waiter.scope;
                 if (scopes !== undefined && (waiterScope === undefined ? !touchesProjection : !scopes.some(scope => sameChangeScope(scope, waiterScope))))
                     continue;
-                this.changeWaiters.delete(waiter);
                 waiter.wake(this.changeVersionOf(waiterScope));
             }
         }