@nanmicoder/dsh-agent-teams 0.1.6 → 0.1.8

package/README.md

@@ -78,7 +78,28 @@ Then ask for a team directly:
 
 Team state is stored under `<workspace>/.agent-teams/`; the Web panel reads that disk truth and combines it with live sub-agent activity.
 
-Member creation is zero-interaction by default: the plugin snapshots the LLM provider, model, and reasoning effort actually used by the captain's current step, and restores that snapshot on later continuations. Only an explicit heterogeneous-team request (for example, “backend on provider A/model X, frontend on provider B/model Y”) supplies a member-specific `provider` + `model`; there is no per-member model or reasoning prompt.
+Member creation is zero-interaction by default: a member on the captain's current LLM route snapshots that provider, model, and reasoning effort, while a member on a requested alternative route snapshots the target model's default effort; later continuations restore the resolved snapshot. Only an explicit heterogeneous-team request (for example, “backend on provider A/model X, frontend on provider B/model Y”) supplies a member-specific `provider` + `model`; there is no per-member model or reasoning prompt.
+
+## Slash command
+
+No “use AgentTeams” phrasing required. The plugin registers the
+closed-namespace `/agent-teams` host command, so the Web GUI slash menu shows
+an `agent-teams` placeholder with an input hint: pick it (or type the
+command), describe the goal, and press Enter.
+
+```
+/agent-teams research the pricing pages of three competitors
+```
+
+The line is claimed by the command pipeline and never reaches the model as
+plain text — the handler queues one deterministic activation message as an
+ordinary follow-up turn, so the captain protocol starts immediately. The
+invocation is durably logged (`command/run` / `command/done`).
+
+Surfaces without command adjudication (for example the headless CLI) get the
+same deterministic activation through a gesture boundary: any genuine user
+message starting with `/agent-teams` activates the protocol for the rest of
+the text. Mid-sentence mentions stay ordinary prose.
 
 ## Configuration
 
@@ -94,7 +115,9 @@ Defaults work without extra setup. A trusted profile can override member behavio
     maxMembers: 8
 ```
 
-`memberProvider` is the sub-agent runtime backend (`spawn` / `fork`), not an LLM provider. Cross-LLM-provider routing uses the optional `provider` + `model` fields of `agent_teams_add_member`; `memberModel` is only a model default for all members.
+`memberProvider` is the sub-agent runtime backend (`spawn` / `fork`), not an LLM provider. Cross-LLM-provider routing uses the optional `provider` + `model` fields of `agent_teams_add_member`; `memberModel` is only a model default for all members. A member on the captain's current provider/model inherits the captain's reasoning effort, while a changed provider or model automatically uses the target model's default. To request a particular effort, pass the optional `reasoning_effort` field — one of the target model's supported effort ids, or `"default"` to force the model's own default.
+
+`slashCommand: false` disables the deterministic `/agent-teams` activation surfaces (slash command and gesture boundary), leaving the natural-language trigger as the only entry point.
 
 ## Boundaries
 

package/README_ZH.md

@@ -78,7 +78,19 @@ dsh web
 
 团队状态保存在 `<workspace>/.agent-teams/`；Web 面板读取这份磁盘真相，并与实时子 Agent 活动合并展示。
 
-成员创建默认零交互：插件会快照队长**当前这一步**实际使用的 LLM provider、model 与思考强度，成员后续续跑仍使用这份快照。只有当用户明确提出异构分工（例如“后端用 provider A/model X，前端用 provider B/model Y”）时，队长才会把对应的 `provider` + `model` 传给该成员；不会逐个弹出模型或思考强度选择。
+成员创建默认零交互：成员沿用队长当前 LLM 路由时会快照该 provider、model 与思考强度；用户要求改用其他路由时，则快照目标模型的默认强度，成员后续续跑仍使用最终解析出的快照。只有当用户明确提出异构分工（例如“后端用 provider A/model X，前端用 provider B/model Y”）时，队长才会把对应的 `provider` + `model` 传给该成员；不会逐个弹出模型或思考强度选择。
+
+## Slash 命令
+
+无需再说“用 AgentTeams”。插件注册了封闭命名空间的 `/agent-teams` 宿主命令，Web GUI 的 slash 菜单会显示 `agent-teams` 占位项与输入提示：选中它（或直接输入命令）、描述目标、回车即可。
+
+```
+/agent-teams 调研三家竞品的定价页
+```
+
+这一行会被命令管线认领，**不会**以纯文本形式发给模型——处理器会以一条确定性激活消息排队一个普通跟进回合，队长协议立即启动。调用会持久化记录（`command/run` / `command/done`）。
+
+没有命令裁决的表面（例如 headless CLI）也享有同等的确定性激活：任何以 `/agent-teams` 开头的真实用户消息，都会为其余文本激活该协议；句子中间出现的字样仍是普通文本。
 
 ## 配置
 
@@ -94,7 +106,9 @@ dsh web
     maxMembers: 8
 ```
 
-这里的 `memberProvider` 指子 Agent 的运行后端（`spawn` / `fork`），不是 LLM provider。跨 LLM provider 由 `agent_teams_add_member` 的可选 `provider` + `model` 参数表达；`memberModel` 只是所有成员的模型默认覆盖。
+这里的 `memberProvider` 指子 Agent 的运行后端（`spawn` / `fork`），不是 LLM provider。跨 LLM provider 由 `agent_teams_add_member` 的可选 `provider` + `model` 参数表达；`memberModel` 只是所有成员的模型默认覆盖。成员沿用队长当前 provider/model 时会继承队长的思考强度；provider 或 model 任一改变时会自动使用目标模型的默认档。需要指定特定强度时，可传入可选的 `reasoning_effort` 参数（目标模型支持的档位 id，或 `"default"` 表示强制使用模型自身默认档）。
+
+`slashCommand: false` 可关闭确定性的 `/agent-teams` 激活面（slash 命令与手势边界），仅保留自然语言触发。
 
 ## 使用边界
 

package/lib/client/ActivityPanel.js

@@ -18,11 +18,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import { IconBranchOutline16, IconCloseOutline16, } from '@deepseek-ai/dsh-client-ui-primitives';
 import { activityPanelExpandedForSession, compactDagLayout, COMPACT_DAG_NODE_HEIGHT, COMPACT_DAG_NODE_WIDTH, dependencyFocusTaskId, relatedTaskIds, usesParallelTaskGrid, } from "./activity-model.js";
+import { getActivityMonitorTargetsSnapshot, getActivitySnapshotsSnapshot, startActivityPolling, subscribeActivityMonitorTargets, subscribeActivitySnapshots, } from "./activity-monitor.js";
 import { ACTION_ART, LEAD_ART, memberArtUrl } from "./artwork.js";
 import { OPEN_PANEL_EVENT } from "./AgentTeamsCard.js";
 import css from './ActivityPanel.module.css';
-/** Poll cadence for the host snapshot route. */
-const POLL_MS = 1000;
 /** Grace before the panel collapses once no team remains. */
 const AUTOCLOSE_GRACE_MS = 2000;
 /**
@@ -31,8 +30,6 @@ const AUTOCLOSE_GRACE_MS = 2000;
  * right after load. New activity after this window auto-expands as usual.
  */
 const AUTO_OPEN_SETTLE_MS = 4000;
-/** Host route serving team snapshots. */
-const STATE_URL = '/plugins/dsh-agent-teams/state';
 /** Root marker shared with the panel CSS while the portal is expanded. */
 const PANEL_OPEN_ATTRIBUTE = 'data-agent-teams-panel-open';
 /** Initial-letter fallback for unmatched roles. */
@@ -263,14 +260,15 @@ export function ActivityPanel({ sessionsList, openSession }) {
         setWasActive(false);
         openSession(id);
     };
-    const [teams, setTeams] = useState([]);
-    const [archivedTeams, setArchivedTeams] = useState([]);
     const [open, setOpen] = useState(false);
     const [openOwner, setOpenOwner] = useState();
     const [autoOpened, setAutoOpened] = useState(false);
     const [wasActive, setWasActive] = useState(false);
     const [historic, setHistoric] = useState(new Map());
     const current = useSyncExternalStore(sessionsList.subscribe, sessionsList.getSnapshot).current;
+    const monitorTargets = useSyncExternalStore(subscribeActivityMonitorTargets, getActivityMonitorTargetsSnapshot);
+    const { teams, archivedTeams } = useSyncExternalStore(subscribeActivitySnapshots, getActivitySnapshotsSnapshot);
+    const currentTargets = useMemo(() => current === undefined ? [] : monitorTargets.filter((target) => target.sessionId === current), [current, monitorTargets]);
     const currentRef = useRef(current);
     useEffect(() => { currentRef.current = current; }, [current]);
     const mountedAtRef = useRef(performance.now());
@@ -299,42 +297,13 @@ export function ActivityPanel({ sessionsList, openSession }) {
         return () => { root.removeAttribute(PANEL_OPEN_ATTRIBUTE); };
     }, [expanded]);
     useEffect(() => {
-        let cancelled = false;
-        let inFlight = false;
-        const tick = async () => {
-            if (inFlight || cancelled)
-                return;
-            inFlight = true;
-            try {
-                const [liveResponse, archivedResponse] = await Promise.all([
-                    fetch(STATE_URL, { cache: 'no-store' }),
-                    fetch(`${STATE_URL}?archived=1`, { cache: 'no-store' }),
-                ]);
-                if (liveResponse.ok) {
-                    const body = (await liveResponse.json());
-                    if (!cancelled && Array.isArray(body.teams))
-                        setTeams(body.teams);
-                }
-                if (archivedResponse.ok) {
-                    const body = (await archivedResponse.json());
-                    if (!cancelled && Array.isArray(body.teams))
-                        setArchivedTeams(body.teams);
-                }
-            }
-            catch {
-                // Host restarting; keep the last snapshot.
-            }
-            finally {
-                inFlight = false;
-            }
-        };
-        void tick();
-        const timer = setInterval(() => { void tick(); }, POLL_MS);
-        return () => {
-            cancelled = true;
-            clearInterval(timer);
-        };
-    }, []);
+        // Installing the plugin alone must not touch the state route. A successful
+        // AgentTeams conversation card registers the demand that reaches here.
+        if (currentTargets.length === 0)
+            return;
+        const controller = startActivityPolling(currentTargets);
+        return () => { controller.stop(); };
+    }, [currentTargets]);
     useEffect(() => {
         const onOpenPanel = (event) => {
             const activeSession = currentRef.current;

package/lib/client/AgentTeamsCard.js

@@ -10,7 +10,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * session is re-opened for review).
  * @module dsh-agent-teams/client/card
  */
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useSyncExternalStore } from 'react';
+import { getActivitySnapshotsSnapshot, monitorAgentTeam, subscribeActivitySnapshots, } from "./activity-monitor.js";
 import { LEAD_ART, memberArtUrl } from "./artwork.js";
 import css from './AgentTeamsCard.module.css';
 /** Window event name the floater listens for to open itself. */
@@ -29,40 +30,17 @@ function openActivityPanel(data) {
     }));
 }
 /** Render one durable team as a compact conversation card. */
-export function AgentTeamsCard({ node, openSession, currentSessionId }) {
+export function AgentTeamsCard({ node, openSession, sessionId }) {
     const data = node.data;
-    const owner = data.captainSessionId || currentSessionId() || '';
-    const [snapshot, setSnapshot] = useState();
+    // `conversation.chat.node` is session-scoped, so its framework-owned id is
+    // a stable owner even while another conversation becomes current.
+    const owner = data.captainSessionId || sessionId;
+    const { teams, archivedTeams } = useSyncExternalStore(subscribeActivitySnapshots, getActivitySnapshotsSnapshot);
     useEffect(() => {
-        let cancelled = false;
-        const tick = async () => {
-            for (const url of ['/plugins/dsh-agent-teams/state', '/plugins/dsh-agent-teams/state?archived=1']) {
-                try {
-                    const response = await fetch(url, { cache: 'no-store' });
-                    if (!response.ok)
-                        continue;
-                    const body = (await response.json());
-                    const found = Array.isArray(body.teams)
-                        ? body.teams.find((team) => team.teamId === data.teamId && (owner === '' || team.captainSessionId === owner))
-                        : undefined;
-                    if (found !== undefined) {
-                        if (!cancelled)
-                            setSnapshot(found);
-                        return;
-                    }
-                }
-                catch {
-                    // Host restarting; retry on the next poll.
-                }
-            }
-        };
-        void tick();
-        const timer = setInterval(() => { void tick(); }, 1500);
-        return () => {
-            cancelled = true;
-            clearInterval(timer);
-        };
+        return monitorAgentTeam(owner, data.teamId);
     }, [data.teamId, owner]);
+    const snapshot = teams.find((team) => team.teamId === data.teamId && (owner === '' || team.captainSessionId === owner))
+        ?? archivedTeams.find((team) => team.teamId === data.teamId && (owner === '' || team.captainSessionId === owner));
     const resolved = useMemo(() => ({
         ...data,
         captainSessionId: snapshot?.captainSessionId ?? owner,

package/lib/client/activity-monitor.js

@@ -0,0 +1,178 @@
+/** Shared, demand-driven state for the AgentTeams browser monitor. */
+const targets = new Map();
+const targetListeners = new Set();
+const snapshotListeners = new Set();
+let targetSnapshot = [];
+let activitySnapshots = { teams: [], archivedTeams: [] };
+function targetKey(sessionId, teamId) {
+    return `${sessionId}\u0000${teamId}`;
+}
+function publishTargets() {
+    targetSnapshot = [...targets.values()]
+        .filter((target) => target.active)
+        .map(({ key, sessionId, teamId }) => ({ key, sessionId, teamId }));
+    for (const listener of targetListeners)
+        listener();
+}
+/** Subscribe to the active monitor-target list (React external-store shape). */
+export function subscribeActivityMonitorTargets(listener) {
+    targetListeners.add(listener);
+    return () => { targetListeners.delete(listener); };
+}
+/** Read the stable active-target snapshot. */
+export function getActivityMonitorTargetsSnapshot() {
+    return targetSnapshot;
+}
+/**
+ * Register one successful AgentTeams card as a monitoring demand.
+ *
+ * The returned cleanup is reference-counted so multiple cards and React
+ * StrictMode remounts cannot stop another card's monitor.
+ */
+export function monitorAgentTeam(sessionId, teamId) {
+    const owner = sessionId.trim();
+    const id = teamId.trim();
+    if (owner === '' || id === '')
+        return () => { };
+    const key = targetKey(owner, id);
+    const existing = targets.get(key);
+    if (existing === undefined) {
+        targets.set(key, { key, sessionId: owner, teamId: id, refs: 1, active: true });
+        publishTargets();
+    }
+    else {
+        existing.refs += 1;
+        if (!existing.active) {
+            existing.active = true;
+            publishTargets();
+        }
+    }
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const current = targets.get(key);
+        if (current === undefined)
+            return;
+        current.refs -= 1;
+        if (current.refs <= 0) {
+            targets.delete(key);
+            if (current.active)
+                publishTargets();
+        }
+    };
+}
+/** Stop polling targets whose final archived snapshot has been captured. */
+export function settleActivityMonitorTargets(keys) {
+    let changed = false;
+    for (const key of keys) {
+        const target = targets.get(key);
+        if (target?.active !== true)
+            continue;
+        target.active = false;
+        changed = true;
+    }
+    if (changed)
+        publishTargets();
+}
+/** Subscribe to the shared live/archive snapshot. */
+export function subscribeActivitySnapshots(listener) {
+    snapshotListeners.add(listener);
+    return () => { snapshotListeners.delete(listener); };
+}
+/** Read the stable shared live/archive snapshot. */
+export function getActivitySnapshotsSnapshot() {
+    return activitySnapshots;
+}
+/** Publish one or both successful state-route responses. */
+export function updateActivitySnapshots(update) {
+    const next = {
+        teams: update.teams ?? activitySnapshots.teams,
+        archivedTeams: update.archivedTeams ?? activitySnapshots.archivedTeams,
+    };
+    if (next.teams === activitySnapshots.teams && next.archivedTeams === activitySnapshots.archivedTeams)
+        return;
+    activitySnapshots = next;
+    for (const listener of snapshotListeners)
+        listener();
+}
+/** Poll cadence for the live host snapshot route. */
+export const ACTIVITY_POLL_MS = 1000;
+/** Host route serving live and archived team snapshots. */
+export const ACTIVITY_STATE_URL = '/plugins/dsh-agent-teams/state';
+/**
+ * Start the single polling loop for the current session's requested targets.
+ *
+ * With no targets this is deliberately inert: installing the plugin must not
+ * touch the state route. Live state is polled at the normal cadence; archive
+ * state is fetched only as a one-time fallback for targets no longer live.
+ */
+export function startActivityPolling(monitorTargets, runtime = {}) {
+    if (monitorTargets.length === 0) {
+        return { firstTick: Promise.resolve(), stop: () => { } };
+    }
+    const fetchState = runtime.fetchState ?? ((url, init) => fetch(url, init));
+    const schedule = runtime.schedule ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
+    const cancel = runtime.cancel ?? ((timer) => { clearInterval(timer); });
+    const publishSnapshots = runtime.publishSnapshots ?? updateActivitySnapshots;
+    const settleTargets = runtime.settleTargets ?? settleActivityMonitorTargets;
+    let cancelled = false;
+    let inFlight = false;
+    let controller;
+    const tick = async () => {
+        if (inFlight || cancelled)
+            return;
+        inFlight = true;
+        controller = new AbortController();
+        try {
+            const liveResponse = await fetchState(ACTIVITY_STATE_URL, {
+                cache: 'no-store',
+                signal: controller.signal,
+            });
+            if (!liveResponse.ok)
+                return;
+            const body = (await liveResponse.json());
+            if (cancelled || !Array.isArray(body.teams))
+                return;
+            const liveTeams = body.teams;
+            publishSnapshots({ teams: liveTeams });
+            const missing = monitorTargets.filter((target) => !liveTeams.some((team) => team.captainSessionId === target.sessionId && team.teamId === target.teamId));
+            if (missing.length === 0)
+                return;
+            // Archives are immutable. A successful fallback retires every missing
+            // target, including legacy cards whose host archive no longer exists.
+            const archivedResponse = await fetchState(`${ACTIVITY_STATE_URL}?archived=1`, {
+                cache: 'no-store',
+                signal: controller.signal,
+            });
+            if (!archivedResponse.ok)
+                return;
+            const archivedBody = (await archivedResponse.json());
+            if (cancelled || !Array.isArray(archivedBody.teams))
+                return;
+            publishSnapshots({ archivedTeams: archivedBody.teams });
+            settleTargets(new Set(missing.map((target) => target.key)));
+        }
+        catch (error) {
+            if (error?.name === 'AbortError')
+                return;
+            // Host restarting; keep the last snapshot and retry on the next tick.
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    const firstTick = tick();
+    const timer = schedule(() => { void tick(); }, ACTIVITY_POLL_MS);
+    return {
+        firstTick,
+        stop: () => {
+            if (cancelled)
+                return;
+            cancelled = true;
+            controller?.abort();
+            cancel(timer);
+        },
+    };
+}

package/lib/client/index.js

@@ -27,7 +27,6 @@ export function apply(ctx) {
         key: 'agent-teams',
         inject: () => ({
             openSession: (id) => { ctx.sessions.open(id); },
-            currentSessionId: () => ctx.sessions.list.getSnapshot().current,
         }),
     }, AgentTeamsCard));
 }