@wowyuarm/dsh-agent-team 0.1.2 → 0.1.4

package/README.md

@@ -5,6 +5,7 @@
 [![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** helps a human manage tasks in an orderly way and use agents as true collaborators: agents are persistent identities for their sessions; Workspaces organize agents and sessions per project; Channels carry responsibilities; Task Threads chain session agents into one line of progress.
 
@@ -12,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,13 +2,21 @@
 
 [English](README.md) | 简体中文
 
+[![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 串成一条推进线。
 
 一个为 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 提供的按需启用插件：只在需要 Team mode 的 profile 安装，普通 DSH Session 保持原有 preset roster。
 
 ## 预览
 
-![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)
 
 ## 快速开始
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowyuarm/dsh-agent-team",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Help humans organize tasks and let agents collaborate - a Team plugin for DeepSeek Harness",
   "repository": {
     "type": "git",
@@ -18,15 +18,17 @@
     "README.zh.md"
   ],
   "scripts": {
-    "generate:typert": "cd ../deepseek-harness && node --import tsx ../dsh-agent-team/scripts/generate-typert.mjs",
+    "generate:typert": "node --import tsx scripts/generate-typert.mjs",
     "prepack": "npm run build",
+    "clean:build-outputs": "node scripts/clean-build-outputs.mjs",
     "test": "npm run generate:typert && vitest run",
     "test:browser": "npm run build && node scripts/run-browser-test.mjs",
     "preview": "node scripts/check-preview-credentials.mjs && npm run build && node scripts/run-preview.mjs",
     "preview:ui": "npm run build && node scripts/run-ui-preview.mjs",
     "lint": "corepack pnpm dlx oxlint@1.76.0 --disable-typescript-plugin packages scripts",
+    "duplication": "jscpd --config .jscpd.json packages scripts",
     "typecheck": "npm run generate:typert && tsc -p packages/agent-team/tsconfig.json && tsc -p packages/tool-agent-team/tsconfig.json && tsc -p packages/client-agent-team/tsconfig.json",
-    "build": "npm run generate:typert && tsc -p packages/agent-team/tsconfig.build.json && tsc -p packages/tool-agent-team/tsconfig.build.json && tsc -p packages/client-agent-team/tsconfig.build.json && node scripts/build-client.mjs"
+    "build": "npm run clean:build-outputs && npm run generate:typert && tsc -p packages/agent-team/tsconfig.build.json && tsc -p packages/tool-agent-team/tsconfig.build.json && tsc -p packages/client-agent-team/tsconfig.build.json && node scripts/build-client.mjs"
   },
   "dsh": {
     "bundle": {
@@ -41,6 +43,7 @@
         "@deepseek-ai/dsh-client-ui-layout",
         "@deepseek-ai/dsh-client-ui-settings-general",
         "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-input-trigger",
         "@deepseek-ai/dsh-client-ui-workspace",
         "@deepseek-ai/dsh-client-locale"
       ]
@@ -56,9 +59,11 @@
     "@types/node": "^24.0.0",
     "@types/react": "~18.3.31",
     "@types/react-dom": "~18.3.7",
+    "jscpd": "^5.0.16",
     "jsdom": "^30.0.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
+    "tsx": "^4.22.4",
     "typescript": "^5.8.3",
     "use-sync-external-store": "1.2.0",
     "vite": "^7.0.0",
@@ -121,12 +126,15 @@
     "@deepseek-ai/dsh-client-locale": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-runtime": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-conversation": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-client-ui-input-trigger": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-layout": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-settings-general": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-sidebar": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-slots": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-client-ui-workspace": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-command-compact": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-compaction": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-home-paths": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-invariants": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-llm": ">=0.1.1-rc.2 <0.2.0",
@@ -136,6 +144,7 @@
     "@deepseek-ai/dsh-session-persistence": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-skill-filesystem": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-storage-domain": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-token-meter": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-tool-bash": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-tool-fs": ">=0.1.1-rc.2 <0.2.0",
     "@deepseek-ai/dsh-tool-fs-search": ">=0.1.1-rc.2 <0.2.0",

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.
+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 会从持久未读状态重新判断是否提示。
+把 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/attachments.js

@@ -17,13 +17,22 @@ export const ATTACHMENT_ORPHAN_TTL_MS = 24 * 60 * 60 * 1000;
 export function attachmentsRoot() {
     return dshHomePath('agent-team', 'attachments', 'v1');
 }
+/** Absolute payload path of one stored attachment, as offered to Member agents. */
+export function attachmentPayloadPath(attachmentId, name) {
+    return join(attachmentsRoot(), attachmentId, name);
+}
 export function newAttachmentId() {
     return randomUUID();
 }
 /** Strip path separators, control characters, and leading dots from one client-supplied name. */
 export function sanitizeFileName(raw) {
-    const cleaned = raw.replaceAll(/[\\/\u0000-\u001f\u007f]/g, '').replaceAll(/^\.+/g, '').trim();
-    return cleaned === '' ? 'attachment' : cleaned.slice(0, 180);
+    // oxlint-disable-next-line no-control-regex -- strip ASCII control characters from client filenames.
+    const cleaned = raw.replaceAll(/[\\/\u0000-\u001f\u007f]/g, '').replaceAll(/^\.+/g, '').trim().slice(0, 180);
+    if (cleaned === '')
+        return 'attachment';
+    // The metadata sidecar owns 'meta.json' inside every entry directory; a
+    // payload with that name would be clobbered by the sidecar and unreadable.
+    return /^meta\.json$/i.test(cleaned) ? `_${cleaned}` : cleaned;
 }
 /** Extension-derived media types for agent-supplied files; unknown types stay generic. */
 const PATH_MEDIA_TYPES = {
@@ -97,16 +106,6 @@ export async function readAttachment(root, attachmentId) {
     const bytes = await readFile(join(dir, payload));
     return { name: meta.name, mediaType: meta.mediaType, byteSize: bytes.byteLength, uploadedAt: meta.uploadedAt, bytes };
 }
-/** Whether an upload with this id still has bytes on disk. */
-export async function attachmentExists(root, attachmentId) {
-    try {
-        await stat(attachmentDir(root, attachmentId));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /** List every cache entry with its upload instant for the GC sweep. */
 export async function scanAttachmentCache(root) {
     let ids;

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

@@ -0,0 +1,163 @@
+import { ManualCompactionError } from '@deepseek-ai/dsh-compaction';
+/** Strict threshold: 200K exactly does not compact. */
+export const AUTO_COMPACTION_TOKEN_LIMIT = 200_000;
+/** 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')
+        return undefined;
+    return [...new Set(operation.data.claims.map(claim => claim.owner))];
+}
+/**
+ * Small Host-side accepted-Task follow-up. This is deliberately not a generic
+ * workflow/state-machine: a pending set deduplicates Members, an error map is
+ * owned by the Host, and each worker is only whenIdle → measure → compactNow.
+ */
+export class AutoCompactionCoordinator {
+    options;
+    pending = new Set();
+    workers = new Map();
+    controller = new AbortController();
+    constructor(options) {
+        this.options = options;
+    }
+    /** Queue all unique claim owners; unavailable Members stay pending. */
+    schedule(memberIds) {
+        for (const memberId of new Set(memberIds)) {
+            this.pending.add(memberId);
+            this.start(memberId);
+        }
+    }
+    /** Activation/recovery calls this after a live handle becomes available. */
+    activated(memberId) {
+        this.start(memberId);
+    }
+    async dispose() {
+        this.controller.abort();
+        await Promise.all([...this.workers.values()].map(worker => worker.catch(() => { })));
+        this.workers.clear();
+        this.pending.clear();
+    }
+    start(memberId) {
+        if (this.controller.signal.aborted || this.workers.has(memberId) || !this.pending.has(memberId))
+            return;
+        // No live handle is not a failure: member activation/recovery calls activated().
+        if (this.options.agentForMember(memberId) === undefined)
+            return;
+        const worker = this.work(memberId).finally(() => { this.workers.delete(memberId); });
+        this.workers.set(memberId, worker);
+    }
+    async work(memberId) {
+        let reactivated = false;
+        while (!this.controller.signal.aborted && this.pending.has(memberId)) {
+            const agent = this.options.agentForMember(memberId);
+            if (agent === undefined)
+                return;
+            try {
+                if (!(await waitForIdleOrAbort(agent, this.controller.signal)))
+                    return;
+            }
+            catch (error) {
+                this.fail(memberId, agent, `automatic compaction idle wait failed: ${describe(error)}`);
+                return;
+            }
+            // A restart can replace the handle while it waited; restart the turn on
+            // the current agent so measurement and compactNow share one scope.
+            if (this.options.agentForMember(memberId) !== agent)
+                continue;
+            const meter = agent.ctx.get('tokenMeter');
+            if (meter === undefined) {
+                this.fail(memberId, agent, 'automatic compaction failed: tokenMeter is unavailable in the Member scope');
+                return;
+            }
+            const 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)
+                // prunes the standing mount while this agent's scope binding still
+                // names the dead key, so resolution can never succeed again for this
+                // handle. One in-place re-activation rebuilds the binding from the
+                // live roster; a preset that mounts no compaction row keeps failing
+                // and lands in the terminal diagnostic below.
+                if (!reactivated && await this.tryReactivate(memberId)) {
+                    reactivated = true;
+                    continue;
+                }
+                this.fail(memberId, agent, 'automatic compaction failed: compaction is unavailable in the Member scope');
+                return;
+            }
+            try {
+                const result = await engine.compactNow(agent, this.controller.signal);
+                if (this.controller.signal.aborted)
+                    return;
+                if (result === null) {
+                    this.fail(memberId, agent, `automatic compaction returned no compactable range above ${AUTO_COMPACTION_TOKEN_LIMIT} tokens`);
+                    return;
+                }
+            }
+            catch (error) {
+                if (this.controller.signal.aborted)
+                    return;
+                if (error instanceof ManualCompactionError && error.code === 'busy')
+                    continue;
+                this.fail(memberId, agent, `automatic compaction failed: ${describe(error)}`);
+                return;
+            }
+            const after = meter.measure(agent.session).totalTokens;
+            if (after >= before) {
+                this.fail(memberId, agent, `automatic compaction did not reduce context (${before} → ${after} tokens)`);
+                return;
+            }
+            this.options.cleared(memberId, agent.id);
+            // Still over the strict threshold: next iteration waits at a fresh idle
+            // boundary before attempting another compactNow.
+        }
+    }
+    complete(memberId, agent) {
+        this.pending.delete(memberId);
+        this.options.cleared(memberId, agent.id);
+    }
+    tryReactivate(memberId) {
+        return this.options.reactivate(memberId).catch(error => {
+            this.options.log(`automatic compaction re-activation failed: ${describe(error)} (member ${memberId})`);
+            return false;
+        });
+    }
+    fail(memberId, agent, diagnostic) {
+        this.pending.delete(memberId);
+        this.options.log(`${diagnostic} (member ${memberId}, session ${agent.id})`);
+        this.options.failed(memberId, agent.id, diagnostic);
+    }
+}
+/** Abortable idle wait; the Agent owns its idle promise and is never cancelled. */
+function waitForIdleOrAbort(agent, signal) {
+    const idle = agent.whenIdle();
+    if (signal.aborted) {
+        // The agent may settle or reject after teardown; keep that late outcome
+        // observed without making it a coordinator failure.
+        void idle.catch(() => { });
+        return Promise.resolve(false);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (outcome, error) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (outcome === 'error')
+                reject(error);
+            else
+                resolve(outcome === 'idle');
+        };
+        const onAbort = () => { finish('aborted'); };
+        signal.addEventListener('abort', onAbort, { once: true });
+        idle.then(() => { finish('idle'); }, error => { finish('error', error); });
+    });
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}