@wowyuarm/dsh-agent-team 0.1.3 → 0.1.5

package/README.md

@@ -13,7 +13,13 @@ An opt-in plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-
 
 ## Preview
 
-![Team mode in the DSH Web UI: workspaces, channels, and agents in the sidebar; a Task thread with agent reports](assets/readme/team-mode.png)
+![Team mode in the DSH Web UI: Channels and seven online Agents in the sidebar; the Main Channel shows Task references and the composer’s task switch](assets/readme/team-mode.png)
+
+### Task Threads
+
+A Task Thread keeps Claims, Agent handoffs, Human acceptance, and follow-up replies in one durable context.
+
+![Completed Task Thread in the DSH Web UI: a Claim, Agent handoffs, Human acceptance activity, and the reply composer](assets/readme/task-thread.png)
 
 ## Quick start
 

package/README.zh.md

@@ -2,6 +2,9 @@
 
 [English](README.md) | 简体中文
 
+[![npm](https://img.shields.io/npm/v/@wowyuarm/dsh-agent-team?style=flat-square)](https://www.npmjs.com/package/@wowyuarm/dsh-agent-team)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+[![Release](https://img.shields.io/github/v/release/wowyuarm/dsh-agent-team?include_prereleases&style=flat-square)](https://github.com/wowyuarm/dsh-agent-team/releases)
 [![Listed on Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com/p/wowyuarm/dsh-agent-team/)
 
 **dsh-agent-team** 帮助 human 有序管理任务、把 agents 用成真正的协作者：Agent 是 session 的持久身份；Workspace 按项目组织 agents 与 sessions；Channel 承载职责分派；Task Thread 把多个 session agent 串成一条推进线。
@@ -10,7 +13,13 @@
 
 ## 预览
 
-![DSH Web UI 中的 Team mode：侧边栏是 Workspace、频道与 Agent；主区是一个 Task Thread，含 Agent 汇报](assets/readme/team-mode.png)
+![DSH Web UI 中的 Team mode：侧边栏展示频道与 7 位在线 Agent；Main 频道含 Task 引用和 composer 的作为任务开关](assets/readme/team-mode.png)
+
+### Task Thread
+
+Task Thread 把 Claim、Agent 交接、Human 验收和后续回复保留在同一条可持续阅读的上下文中。
+
+![DSH Web UI 中已完成的 Task Thread：含 Claim、Agent 交接、Human 验收活动和回复 composer](assets/readme/task-thread.png)
 
 ## 快速开始
 
@@ -92,7 +101,7 @@ dsh web
 
 ## 开发
 
-维护中的文档入口是 [`docs/README.md`](docs/README.md)。常用检查命令：
+维护中的文档入口是 [`docs/README.zh.md`](docs/README.zh.md)。常用检查命令：
 
 ```sh
 corepack pnpm install
@@ -106,7 +115,7 @@ npm pack --dry-run
 
 `npm run test:browser` 使用相邻的 `../deepseek-harness` checkout、隔离临时 profile 和 `/usr/bin/google-chrome`（可用 `CHROME_PATH` 覆盖），不需要 provider credentials。手动检查时，`npm run preview:ui` 会加载不调用模型的 Team fixture；`DEEPSEEK_API_KEY=... npm run preview` 会启动真实 provider preview。两个 preview 命令都会在 `Ctrl+C` 后清理临时状态。
 
-架构和协作协议见 [`docs/architecture.md`](docs/architecture.md) 与 [`docs/team-collaboration.md`](docs/team-collaboration.md)。
+架构和协作协议见 [`docs/architecture.zh.md`](docs/architecture.zh.md) 与 [`docs/team-collaboration.zh.md`](docs/team-collaboration.zh.md)。
 
 ## 许可证
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowyuarm/dsh-agent-team",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Help humans organize tasks and let agents collaborate - a Team plugin for DeepSeek Harness",
   "repository": {
     "type": "git",

package/packages/agent-team/README.md

@@ -20,9 +20,9 @@ Member creation commits one stable Member/session/Workspace/preset/private-memor
 
 Every team-managed session records `danger-full-access`. Project cwd remains the Workspace path, while private memory lives under `$DSH_HOME/agent-team/members/<memberId>/`. An untitled Member session is named with its handle through the session-title service, so the ordinary Session list shows the Member identity; an explicit rename or any earlier title always wins. The isolated `team-member` preset also provides coding tools including model-facing web search, Workspace instruction discovery, and Team protocol guidance. The host owns the shared Web service and provider; the preset mounts only the model-facing web tool. Its lowercase `memory.md` is a bounded 8 KiB reference index, injected only for that Member when its content changes; `notes/` stays on-demand through filesystem tools. Over-budget indexes receive a maintenance warning, not silent truncation. Ordinary sessions and forks receive no Team identity or private-memory context. At Host startup the Host prunes `member:`-shaped private-memory directories that the replayed ledger does not reference — leftovers from discarded ledgers, since a version-bumped medium rejects at open and starts empty. Prune failures fail startup; entries outside the `member:` shape are left untouched.
 
-Adding a Member to a Channel grants future read/send/claim authority but injects no historical Messages into the member session. Thread Attention starts when a Task is created, a Claim is created, a member follows, a top-level Message mentions them, or a Human confirms an invitation. Ordinary unread is derived from Attention; structured mentions create durable direct markers, while terminal Task changes retain sparse Activity markers for affected followers after Attention ends. `team_inbox` and Thread reads are Host projections, not Session inbox contents. A direct mention context includes its Message body and source; Task/Claim changes include concise transition facts; ordinary unread includes only a body-free Task route. Pending hints are coalesced, ignored hints do not loop, and resume/error recovery derives a new hint from durable unread state. For recoverable service failures, the Host wakes a Member after each of the first two consecutive `agent/error` occurrences, then leaves the third failure for the operator; only a clean turn resets that run.
+Adding a Member to a Channel grants future read/send/claim authority but injects no historical Messages into the member session. Every top-level Message creates a Thread; new Client/tool starts explicitly choose taskless while released-client omission remains taskful, and a Human can later promote a taskless Thread by atomically adding its Task overlay and a structured `promote` Task activity. Thread Attention starts when a Thread is created, a Claim is created, a member follows, a top-level Message mentions them, or a Human confirms an invitation. Ordinary unread is derived from Attention; structured mentions create durable direct markers, while terminal Task changes retain sparse Activity markers for affected followers after Attention ends. `team_inbox` and Thread reads are Host projections, not Session inbox contents. A direct mention context includes its Message body and source; Task/Claim changes — including promotion — include concise transition facts; ordinary unread carries a body-free Thread-first route. Pending hints are coalesced, ignored hints do not loop, and resume/error recovery derives a new hint from durable unread state. For recoverable service failures, the Host wakes a Member after each of the first two consecutive `agent/error` occurrences, then leaves the third failure for the operator; only a clean turn resets that run.
 
-Member replies require the exact current Thread revision and atomically update Message and Thread facts. 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. Top-level Messages may mention Agents directly: mentioned Members start following the new Thread. In an existing Thread, a Human reply mentioning an unfollowed Agent requires a process-local, one-use confirmation token before the operation commits, while such Member replies are rejected with member_not_following. Message facts carry their structured mention 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.
+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 an unfollowed Agent requires a process-local, one-use confirmation token before the operation commits, while such Member replies are rejected with member_not_following. Message facts carry their structured mention 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 commits durably but derives no scope, because it advances only the reader's private watermark. 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.
 
@@ -40,7 +40,7 @@ A team-enabled preset registers the five tools in its own agent scope and marks
 
 #### What the model sees
 
-An enabled Member may receive one bounded, coalesced context notification after durable unread work appears. Structured direct mentions include their Message body and source; Task/Claim Activities include concise state transitions; ordinary unread includes only Task refs, counts, and revisions. The notification is queued at the Agent's safe step boundary, so active model requests and tools are not interrupted. It routes the common path directly to `team_thread.read`; the model uses `team_inbox` only when it needs to triage remaining Threads.
+An enabled Member may receive one bounded, coalesced context notification after durable unread work appears. Structured direct mentions include their Message body and source; Task/Claim Activities include concise state transitions; ordinary unread includes only a Thread-first route, counts, and revisions, with a Task overlay where present. The notification is queued at the Agent's safe step boundary, so active model requests and tools are not interrupted. It routes the common path directly to `team_thread.read`; the model uses `team_inbox` only when it needs to triage remaining Threads.
 
 #### Token effect
 

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

@@ -20,9 +20,9 @@ Service 使用 `ctx.storageDomain`、`ctx.workspaceRegistry`、`ctx.agents`、`c
 
 每个 Team 管理的 session 都会持久写入 `danger-full-access`。项目 cwd 仍是 Workspace 路径，私有记忆位于 `$DSH_HOME/agent-team/members/<memberId>/`。没有标题的 Member session 会通过 session-title service 以 handle 命名，普通 Session 列表因此直接显示 Member 身份；显式重命名或任何既有标题始终优先。隔离的 `team-member` preset 还提供 coding 工具、面向模型的 Web 搜索、Workspace instruction discovery 和 Team protocol guidance。共享的 Web service 与 provider 仍由 Host 持有；preset 只挂载面向模型的 Web tool。小写 `memory.md` 是有界的 8 KiB 参考索引，只有该 Member 的内容变化时才注入；`notes/` 只通过 filesystem tools 按需读取。超预算索引只产生维护警告，不静默截断。普通 session 和 fork 不获得 Team 身份或私有记忆上下文。Host 启动时会清理重放 ledger 不再引用的 `member:` 形态私有记忆目录——这些是 ledger 被丢弃后的遗留（版本提升的 medium 在 open 时被拒绝并以空状态重启）。清理失败会使启动失败；非 `member:` 形态的条目保持原样。
 
-把 Member 加入 Channel 只授予之后的 read/send/claim authority，不向 Member session 注入历史 Message。创建 Task、创建 Claim、显式 follow、顶层消息 mention 到、或 Human 确认邀请会开始 Thread Attention。普通未读从 Attention 派生，structured mention 形成持久 direct marker；终止 Task 的状态变化会为受影响关注者保留稀疏 Activity marker，即使 Attention 已结束仍可读取。`team_inbox` 和 Thread read 是 Host projection，不是 Session inbox 内容。Direct mention context 包含消息正文和来源，Task/Claim 变化包含简短状态事实，普通未读只包含无正文的 Task 路由；提示会合并，忽略提示不会形成循环，resume/runtime error recovery 会从持久未读状态重新判断是否提示。对于可恢复的服务错误，Host 会在连续 `agent/error` occurrence 的前两次后唤醒 Member；第 3 次错误则交给 operator，只有 clean turn 才会重置这段连续错误。
+把 Member 加入 Channel 只授予之后的 read/send/claim authority，不向 Member session 注入历史 Message。每条顶层 Message 都创建 Thread；新 Client/tool 显式选择 taskless，released Client 省略意图时仍保持 taskful；Human 可之后 promotion taskless Thread，原子附加 Task overlay 与结构化 `promote` Task activity。创建 Thread、创建 Claim、显式 follow、顶层消息 mention 到、或 Human 确认邀请会开始 Thread Attention。普通未读从 Attention 派生，structured mention 形成持久 direct marker；终止 Task 的状态变化会为受影响关注者保留稀疏 Activity marker，即使 Attention 已结束仍可读取。`team_inbox` 和 Thread read 是 Host projection，不是 Session inbox 内容。Direct mention context 包含消息正文和来源，Task/Claim 变化（含 promotion）包含简短状态事实，普通未读提供无正文的 Thread-first 路由。提示会合并，忽略提示不会形成循环，resume/runtime error recovery 会从持久未读状态重新判断是否提示。对于可恢复的服务错误，Host 会在连续 `agent/error` occurrence 的前两次后唤醒 Member；第 3 次错误则交给 operator，只有 clean turn 才会重置这段连续错误。
 
-Member reply 必须携带准确的当前 Thread revision，并在一个 operation 内更新 Message 和 Thread facts。未读工作必须先 read；revision 过期时拒绝写入。Closed Task 拒绝 reply 和新的 Attention；reopen 恢复 Task，但不恢复之前的 Attention。顶层消息可以直接 mention Agent：被 mention 的 Member 会开始关注新 Thread。在既有 Thread 中，Human 的 reply 提到 unfollowed Agent 时必须先取得 process-local one-use confirmation token 才提交 operation；Member 的此类 reply 会以 member_not_following 拒绝。Message fact 携带自身的 structured mention 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。
+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 提到 unfollowed Agent 时必须先取得 process-local one-use confirmation token 才提交 operation；Member 的此类 reply 会以 member_not_following 拒绝。Message fact 携带自身的 structured mention 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，因为它只推进读者自己的私有水位。每次提交后，Host 只通知 Inbox projection 可能被该 operation 改变的 Member——即 operation 的 Attention/marker delta 加上被触及 Thread 的当前关注者——而不是全部在线 Agent。
 
@@ -40,7 +40,7 @@ Team-enabled preset 在自身 Agent scope 注册五个工具，并用 `markAgent
 
 #### What the model sees
 
-启用的 Member 在持久未读工作出现后，可能收到一次有界、合并的 context 通知。Structured direct mention 包含消息正文和来源；Task/Claim Activity 包含简短状态变化；普通未读只包含 Task ref、数量和 revision。通知通过 Agent 的安全 step 边界排队，正在执行的模型请求和工具不会被中断。常见路径可以直接调用 `team_thread.read`；只有需要跨 Thread 分流时才调用 `team_inbox`。
+启用的 Member 在持久未读工作出现后，可能收到一次有界、合并的 context 通知。Structured direct mention 包含消息正文和来源；Task/Claim Activity 包含简短状态变化；普通未读只包含 Thread-first 路由、数量和 revision，存在时附带 Task overlay。通知通过 Agent 的安全 step 边界排队，正在执行的模型请求和工具不会被中断。常见路径可以直接调用 `team_thread.read`；只有需要跨 Thread 分流时才调用 `team_inbox`。
 
 #### Token effect
 

package/packages/agent-team/lib/auto-compaction.js

@@ -1,6 +1,15 @@
 import { ManualCompactionError } from '@deepseek-ai/dsh-compaction';
 /** Strict threshold: 200K exactly does not compact. */
 export const AUTO_COMPACTION_TOKEN_LIMIT = 200_000;
+/**
+ * Suggested summary marker of the pre-compaction memory hint. Same shape as
+ * the inbox and recovery notices so future turns can recognize it.
+ */
+export const PRE_COMPACTION_NOTICE_SUMMARY = 'Compaction is imminent; consider persisting key conclusions.';
+/** Suggested pre-compaction hint body; writing is the Agent's own call. */
+export function preCompactionNoticeText() {
+    return 'This session is about to be compacted, which will summarize away the current conversation detail. If there are durable conclusions worth keeping — validated facts, decisions, or reusable details — consider writing them to your memory or notes now. This is only a reminder: decide yourself whether anything is worth persisting, and do nothing if not. Do not start new work because of this message.';
+}
 /** Claim owners of a durable Human acceptance, including early-completed ones. */
 export function acceptedTaskCompactionMembers(operation) {
     if (operation.kind !== 'team/task-changed' || operation.actor.kind !== 'human' || operation.data.activity.kind !== 'accept')
@@ -69,11 +78,40 @@ export class AutoCompactionCoordinator {
                 this.fail(memberId, agent, 'automatic compaction failed: tokenMeter is unavailable in the Member scope');
                 return;
             }
-            const before = meter.measure(agent.session).totalTokens;
+            let before = meter.measure(agent.session).totalTokens;
             if (before <= AUTO_COMPACTION_TOKEN_LIMIT) {
                 this.complete(memberId, agent);
                 return;
             }
+            // The session is over the threshold and about to be compacted: steer one
+            // advisory hint so the Agent can persist its own key conclusions first.
+            // The hint turn itself is ordinary agent work — its failure is contained
+            // by the agent loop and never blocks compaction; only the fresh idle
+            // boundary is awaited before the final measurement and compactNow.
+            if (this.options.steerPreCompaction !== undefined) {
+                try {
+                    this.options.steerPreCompaction(agent);
+                }
+                catch (error) {
+                    this.options.log(`pre-compaction memory hint failed: ${describe(error)} (member ${memberId}, session ${agent.id})`);
+                }
+                try {
+                    if (!(await waitForIdleOrAbort(agent, this.controller.signal)))
+                        return;
+                }
+                catch (error) {
+                    this.options.log(`pre-compaction hint idle wait failed: ${describe(error)} (member ${memberId}, session ${agent.id})`);
+                }
+                if (this.controller.signal.aborted)
+                    return;
+                if (this.options.agentForMember(memberId) !== agent)
+                    continue;
+                before = meter.measure(agent.session).totalTokens;
+                if (before <= AUTO_COMPACTION_TOKEN_LIMIT) {
+                    this.complete(memberId, agent);
+                    return;
+                }
+            }
             const engine = this.options.compactionForAgent(agent);
             if (engine === undefined) {
                 // A roster-subtree teardown (bundle-row reload, config hot-apply)

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

@@ -52,7 +52,7 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import { effectiveSandboxMode, setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { ATTACHMENT_MAX_BYTES, attachmentPayloadPath, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
-import { acceptedTaskCompactionMembers, AutoCompactionCoordinator } from "./auto-compaction.js";
+import { acceptedTaskCompactionMembers, AutoCompactionCoordinator, PRE_COMPACTION_NOTICE_SUMMARY, preCompactionNoticeText } from "./auto-compaction.js";
 import { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
 import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_CONSECUTIVE_ERRORS } from "./recovery.js";
 import { agentTeamDomainSpec } from "./spec.js";
@@ -96,8 +96,10 @@ let AgentTeam = (() => {
     let _updateChannel_decorators;
     let _addMember_decorators;
     let _recoverMember_decorators;
+    let _clearMemberContext_decorators;
     let _updateMember_decorators;
     let _changeTask_decorators;
+    let _promoteThread_decorators;
     let _joinChannel_decorators;
     let _removeChannelMember_decorators;
     let _sendMessage_decorators;
@@ -120,8 +122,10 @@ let AgentTeam = (() => {
             _updateChannel_decorators = [Remote('updateChannel')];
             _addMember_decorators = [Remote('addMember')];
             _recoverMember_decorators = [Remote('recoverMember')];
+            _clearMemberContext_decorators = [Remote('clearMemberContext')];
             _updateMember_decorators = [Remote('updateMember')];
             _changeTask_decorators = [Remote('changeTask')];
+            _promoteThread_decorators = [Remote('promoteThread')];
             _joinChannel_decorators = [Remote('joinChannel')];
             _removeChannelMember_decorators = [Remote('removeChannelMember')];
             _sendMessage_decorators = [Remote('sendMessage')];
@@ -141,8 +145,10 @@ let AgentTeam = (() => {
             __esDecorate(this, null, _updateChannel_decorators, { kind: "method", name: "updateChannel", static: false, private: false, access: { has: obj => "updateChannel" in obj, get: obj => obj.updateChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _addMember_decorators, { kind: "method", name: "addMember", static: false, private: false, access: { has: obj => "addMember" in obj, get: obj => obj.addMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _recoverMember_decorators, { kind: "method", name: "recoverMember", static: false, private: false, access: { has: obj => "recoverMember" in obj, get: obj => obj.recoverMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _clearMemberContext_decorators, { kind: "method", name: "clearMemberContext", static: false, private: false, access: { has: obj => "clearMemberContext" in obj, get: obj => obj.clearMemberContext }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateMember_decorators, { kind: "method", name: "updateMember", static: false, private: false, access: { has: obj => "updateMember" in obj, get: obj => obj.updateMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _changeTask_decorators, { kind: "method", name: "changeTask", static: false, private: false, access: { has: obj => "changeTask" in obj, get: obj => obj.changeTask }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __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, _sendMessage_decorators, { kind: "method", name: "sendMessage", static: false, private: false, access: { has: obj => "sendMessage" in obj, get: obj => obj.sendMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -213,6 +219,14 @@ let AgentTeam = (() => {
                     this.emitAutoCompactionChanged(memberId);
                 },
                 log: message => { this.ctx.logger.warn(`agent-team: ${message}`); },
+                // Advisory only: the Agent decides whether anything is worth persisting.
+                steerPreCompaction: agent => {
+                    const hint = createUserMessage({
+                        content: [{ type: 'text', text: preCompactionNoticeText() }],
+                        source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PRE_COMPACTION_NOTICE_SUMMARY },
+                    });
+                    agent.steer(hint);
+                },
             });
         }
         /** Open the durable ledger and restore every enabled Member independently. */
@@ -243,8 +257,15 @@ let AgentTeam = (() => {
                     this.notifyMember(agent);
                 }
                 // A turn that ends without an error closes any automatic recovery episode.
-                if (status === 'idle' && member !== undefined && this.memberFailures.get(member.memberId)?.runtime === undefined) {
-                    this.recovery.onCleanTurnEnd(member.memberId);
+                // The idle transition is itself presence-affecting (working → available),
+                // so it must wake workspace watchers exactly like the running transition
+                // above; without this wake, cached Client member rows keep showing the
+                // Member as working after every turn until an unrelated change arrives.
+                if (status === 'idle' && member !== undefined) {
+                    if (this.memberFailures.get(member.memberId)?.runtime === undefined) {
+                        this.recovery.onCleanTurnEnd(member.memberId);
+                    }
+                    this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
                 }
             });
             const domain = await this.ctx.storageDomain.open(agentTeamDomainSpec);
@@ -426,9 +447,11 @@ let AgentTeam = (() => {
             });
         }
         /**
-         * Operator nudge for an error-stopped Member: steer a continuation prompt
-         * into its live session. Runtime-only — no ledger operation, no suspend.
-         * Taking over manually also cancels any pending automatic recovery episode.
+         * Operator nudge for a Member that stopped making progress: steer a
+         * continuation prompt into its live session, rebuild it after an orphaned
+         * preset composition, or re-run activation when no live session exists.
+         * Runtime-only — no ledger operation, no suspend. Taking over manually also
+         * cancels any pending automatic recovery episode.
          */
         async recoverMember(request) {
             this.requireAccepting();
@@ -444,10 +467,80 @@ let AgentTeam = (() => {
                 await this.reactivateMember(request.memberId);
                 return Object.freeze({ status: this.memberStatus(member) });
             }
+            // A failed activation also leaves nothing to steer; re-running it is the
+            // only way back. A renewed failure stays non-throwing: the refreshed
+            // status carries the activation diagnostic for the sidebar.
+            if (handle === undefined) {
+                if (member.state !== 'enabled')
+                    throw new Error(`Agent Member '${member.handle}' is ${member.state}; only enabled Members can be restarted`);
+                this.ctx.logger.info(`agent-team: restarting member '${member.handle}' after a failed activation`);
+                await this.reactivateMember(request.memberId);
+                return Object.freeze({ status: this.memberStatus(member) });
+            }
             this.ctx.logger.info(`agent-team: operator asked member '${member.handle}' to resume`);
             this.steerResume(member, this.manualResumeText());
             return Object.freeze({ status: this.memberStatus(member) });
         }
+        /**
+         * Start one enabled Member from a new context: dispose the live handle,
+         * archive the previous Session (its log stays on disk for history), and
+         * activate a fresh Session under a new sessionId, so preset, tools, private
+         * memory, and model selection all reload while the next turn carries no
+         * history. The durable operation moves the Member's sessionId; identity,
+         * memory path, and binding survive. A new id is what keeps the Web Client
+         * seat live: a disposed generation's resident instance keeps its `removed`
+         * bit forever, so renewing under the same id would leave a permanently
+         * grayed session view.
+         */
+        async clearMemberContext(request) {
+            return this.enqueueLifecycle(async () => {
+                this.requireAccepting();
+                this.requireWorkspace(request.workspaceId);
+                const stored = this.requireLedger().getMember(request.memberId);
+                if (stored === undefined || stored.workspaceId !== 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`);
+                const active = this.handles.get(request.memberId);
+                if (active === undefined)
+                    throw new Error(`Agent Member '${stored.handle}' has no active session to clear`);
+                if (this.runningAgents.has(active.agent.id))
+                    throw new Error(`Agent Member '${stored.handle}' is still running; wait for the current turn to end before starting from a new context`);
+                const previousSessionId = stored.sessionId;
+                // The fresh id derives from the requestId, so a retried identical
+                // request mints the same id and the ledger dedupes it instead of
+                // colliding; the format matches addMember's `agent-team-<uuid>`.
+                const sessionId = SessionId(`agent-team-${request.requestId}`);
+                const result = await this.requireLedger().renewMemberSession({ ...request, sessionId, actor: agentTeamHumanActor() });
+                if (result.committed)
+                    this.emitCommitted(result.value.receipt);
+                else {
+                    // A retried identical request already renewed this Member; report the
+                    // recorded outcome without another dispose/reactivate cycle.
+                    return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
+                }
+                const renewed = result.value.member;
+                // Drop the old handle's transient state: pending recovery episodes and
+                // error markers belong to the disposed agent, not to the Member.
+                this.recovery.stopTracking(request.memberId);
+                await active.dispose();
+                this.handles.delete(request.memberId);
+                this.modelSelections.delete(request.memberId);
+                this.clearMemberFailure(request.memberId, 'activation');
+                this.clearMemberNotificationState(request.memberId);
+                // The previous log survives on disk; archiving hides it from every
+                // grouping surface so one Member keeps exactly one visible Session.
+                await this.ctx.workspaceRegistry.archiveSession(previousSessionId);
+                await this.activateMember(renewed, undefined, undefined, previousSessionId);
+                const reactivated = this.handles.get(request.memberId);
+                if (reactivated === undefined) {
+                    // Reactivation failed; the activation diagnostic carries the reason and
+                    // the durable renewal stays honest about the attempt.
+                    throw new Error(`Agent Member '${stored.handle}' failed to start a new context: ${this.memberFailures.get(request.memberId)?.activation ?? 'unknown error'}`);
+                }
+                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(renewed) });
+            });
+        }
         /** Ledger handle for log lines; falls back to the raw id when unknown. */
         memberLabel(memberId) {
             return this.ledger?.getMember(memberId)?.handle ?? memberId;
@@ -545,6 +638,14 @@ let AgentTeam = (() => {
             this.emitCommittedOutcome(result);
             return result.value;
         }
+        /** Human-only promotion of a taskless Thread into a real Task plus public Message. */
+        async promoteThread(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const result = await this.requireLedger().promoteThread({ ...request, actor: agentTeamHumanActor() });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
         /** Human-only Channel membership grant; it never injects historical Thread bodies. */
         async joinChannel(request) {
             const actor = this.humanCall(request.workspaceId);
@@ -564,7 +665,7 @@ let AgentTeam = (() => {
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
-        /** Human top-level Task creation; unfollowed Agent mentions use the two-send result. */
+        /** Human top-level Thread start; asTask attaches an optional Task overlay. */
         async sendMessage(request) {
             return this.sendMessageAs(this.humanCall(request.workspaceId), request);
         }
@@ -667,7 +768,7 @@ let AgentTeam = (() => {
             this.requireWorkspace(request.workspaceId);
             return this.requireLedger().view(request);
         }
-        /** Agent-only top-level Task creation. Workspace identity is verified against the live binding. */
+        /** Agent-only top-level Thread start. Workspace identity is verified against the live binding. */
         async sendMessageForAgent(agent, request) {
             return this.sendMessageAs(this.memberCall(agent, request.workspaceId), request);
         }
@@ -808,7 +909,7 @@ let AgentTeam = (() => {
                     throw error;
             }
         }
-        async activateMember(member, knownWorkspacePath, knownSessions) {
+        async activateMember(member, knownWorkspacePath, knownSessions, forkedFrom) {
             if (this.handles.has(member.memberId))
                 return;
             let created;
@@ -842,7 +943,9 @@ let AgentTeam = (() => {
                     ? await this.ctx.agents.resume({ resumeSessionId: member.sessionId, agentOptions, setup })
                     : await this.ctx.agents.create({
                         sessionId: member.sessionId,
-                        meta: { cwd: workspacePath, agentPreset: member.presetId },
+                        // A context renewal records its fork lineage so the archived
+                        // previous Session stays discoverable from the durable header.
+                        meta: { cwd: workspacePath, agentPreset: member.presetId, ...(forkedFrom === undefined ? {} : { parentSession: forkedFrom }) },
                         agentOptions,
                         setup,
                     });
@@ -1086,7 +1189,8 @@ let AgentTeam = (() => {
                         const sender = fact.message.sender === AGENT_TEAM_HUMAN_MEMBER_ID
                             ? 'human' : this.requireLedger().getMember(fact.message.sender)?.handle ?? fact.message.sender;
                         const detail = ['Direct Team mention', `From: ${sender}`, `Channel: ${item.channelRef}`,
-                            `Task: ${item.task.taskRef}`, `Thread: ${item.thread.threadRef}`, `Message ref: ${fact.message.messageRef}`,
+                            ...(item.task === undefined ? [] : [`Task: ${item.task.taskRef}`]),
+                            `Thread: ${item.thread.threadRef}`, `Message ref: ${fact.message.messageRef}`,
                             `Message: ${this.boundedNotificationBody(fact.message.body)}`].join('\n');
                         if (append(detail))
                             detailedFactCount += 1;
@@ -1098,12 +1202,14 @@ let AgentTeam = (() => {
                     }
                 }
                 const ordinaryCount = facts.filter(entry => entry.fact.kind === 'message' && !entry.direct).length;
-                if (ordinaryCount > 0)
-                    append(`Task ${item.task.taskRef}: ${ordinaryCount} unread update${ordinaryCount === 1 ? '' : 's'}.`);
+                if (ordinaryCount > 0) {
+                    const route = item.task === undefined ? `Thread ${item.thread.threadRef}` : `Task ${item.task.taskRef}`;
+                    append(`${route}: ${ordinaryCount} unread update${ordinaryCount === 1 ? '' : 's'}.`);
+                }
             }
             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 taskRef 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 threadRef before acting or replying. Use team_inbox only when you need to triage the remaining Threads.');
             return sections.join('\n\n');
         }
         boundedNotificationBody(body) {
@@ -1125,6 +1231,9 @@ let AgentTeam = (() => {
             if (activity.kind === 'claims_released') {
                 return `Team Task update\n${actor}'s Claims ${activity.claimRefs.join(', ')} were released on Task ${activity.taskRef}.`;
             }
+            if (activity.kind === 'promote') {
+                return `Team Task update\n${actor} created Task ${activity.taskRef} from Thread ${activity.threadRef}; it is open for claims.`;
+            }
             const released = 'releasedClaimRefs' in activity && activity.releasedClaimRefs !== undefined && activity.releasedClaimRefs.length > 0
                 ? ` Released Claims: ${activity.releasedClaimRefs.join(', ')}.` : '';
             return `Team Task update\n${actor} ${activity.kind} Task ${activity.taskRef}.${released}`;