@wowyuarm/dsh-agent-team 0.1.11 → 0.1.12

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

@@ -1,4 +1,4 @@
-import { AgentTeamDmDeliveryError, markAgentTeamPreset } from '@wowyuarm/dsh-agent-team/host';
+import { AGENT_TEAM_HUMAN_HANDLE, AgentTeamDmDeliveryError, markAgentTeamPreset } from '@wowyuarm/dsh-agent-team/host';
 import { formatTeamTimestamp } from '@wowyuarm/dsh-agent-team/time-format';
 import { registerContextTools } from "./context-tools.js";
 import { member, service } from "./host-access.js";
@@ -167,7 +167,7 @@ const teamInbox = defineTool({
 });
 const teamThread = defineTool({
     name: 'team_thread',
-    description: 'Read or manage your Attention on one Thread. read acknowledges one chronological batch of unread facts and is the only read-side source of a next-write token — and only once no unread remains; your own committed public mutations hand off the token as well. history pages older facts without changing read state; status, follow, and unfollow change or report Attention only and render no Thread timeline. Prefer threadRef; taskRef is a compatibility alias when the Thread has a Task.',
+    description: 'Read or manage your Attention on one Thread. read acknowledges one chronological batch of unread facts and is the only read-side source of a next-write token — and only once no unread remains; your own committed public mutations hand off the token as well. A read orients on the Thread anchor and that batch, never the whole Thread: a Member re-entering one it has read before gets no background at all, so the facts between are its own to page back to. history pages older facts without changing read state; status, follow, and unfollow change or report Attention only and render no Thread timeline. Prefer threadRef; taskRef is a compatibility alias when the Thread has a Task.',
     parameters: {
         action: { type: 'string', required: true, enum: ['status', 'follow', 'unfollow', 'read', 'history'] },
         threadRef: { type: 'string', description: "Full branded Thread ref exactly as returned by Team tools, including the 'thread:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
@@ -178,7 +178,7 @@ const teamThread = defineTool({
         schema: { type: 'object', additionalProperties: false, properties: {
                 kind: { type: 'string', required: true }, threadRef: { type: 'string', required: true }, taskRef: { type: 'string' },
                 revision: { type: 'number', required: true }, status: { type: 'string' }, resolution: { type: 'string' }, taskNumber: { type: 'number' },
-                following: { type: 'boolean', required: true }, readThroughSequence: { type: 'number' }, remainingUnreadCount: { type: 'number' }, cursor: { type: 'number' }, hasMore: { type: 'boolean' },
+                following: { type: 'boolean', required: true }, readThroughSequence: { type: 'number' }, remainingUnreadCount: { type: 'number' }, earlierFactCount: { type: 'number' }, cursor: { type: 'number' }, hasMore: { type: 'boolean' },
                 anchor: { type: 'object', required: true, additionalProperties: false, properties: {
                         messageRef: { type: 'string', required: true }, sender: { type: 'string', required: true }, body: { type: 'string', required: true }, sequence: { type: 'number', required: true }, occurredAt: { type: 'string' },
                     } },
@@ -263,6 +263,13 @@ const teamThread = defineTool({
             else
                 lines.push(...facts.map(fact => factLine(fact)));
             lines.push('', `Read through sequence ${value.readThroughSequence}; ${remaining} unread update(s) remaining${remaining > 0 ? ' — call team_thread read again.' : '.'}`);
+            // What this bounded read answered with is the newest batch; the span
+            // before the watermark is the orientation it did not supply. Rendering
+            // the count is what lets a returning reader see the size of that span
+            // instead of assuming the batch is the Thread.
+            const earlier = value.earlierFactCount ?? 0;
+            if (earlier > 0)
+                lines.push(`Earlier facts: ${earlier} — read older ones with team_thread.history.`);
             if (value.contextAdvice !== undefined)
                 lines.push('', ...adviceLines(value.contextAdvice));
             if (remaining === 0)
@@ -311,7 +318,7 @@ const teamThread = defineTool({
         const read = await host.readThreadForAgent(agent, { requestId: requestId(agent.id, exec.callId), ...base });
         return threadResult('read', read, read.attention, read.facts.map(entry => entry.fact.kind === 'message'
             ? { sequence: entry.fact.sequence, kind: 'message', body: entry.fact.message.body, sender: entry.fact.message.sender, mentions: [...entry.fact.mentions], unread: entry.unread, direct: entry.direct, occurredAt: entry.fact.occurredAt }
-            : activityFactView(entry.fact.sequence, entry.fact.activity, { unread: entry.unread, direct: entry.direct }, entry.fact.occurredAt)), { readThroughSequence: read.readThroughSequence, remainingUnreadCount: read.remainingUnreadCount, ...(read.contextAdvice === undefined ? {} : { contextAdvice: adviceView(read.contextAdvice) }), ...taskNumberOf(read.task) });
+            : activityFactView(entry.fact.sequence, entry.fact.activity, { unread: entry.unread, direct: entry.direct }, entry.fact.occurredAt)), { readThroughSequence: read.readThroughSequence, remainingUnreadCount: read.remainingUnreadCount, ...(read.earlierFactCount === undefined ? {} : { earlierFactCount: read.earlierFactCount }), ...(read.contextAdvice === undefined ? {} : { contextAdvice: adviceView(read.contextAdvice) }), ...taskNumberOf(read.task) });
     },
 });
 /** One rendered fact line; markers are inline, never a separate ellipsis line. */
@@ -348,7 +355,7 @@ function adviceLines(advice) {
 }
 const teamMessage = markAgentTeamPreset(defineTool({
     name: 'team_message',
-    description: 'Start a top-level Thread, reply to an existing Thread, or send a direct message (DM). Read the Thread first: a reply needs the current next-write token from a fully drained team_thread read (or your own last committed mutation), and unread work rejects before staleness is even checked. start defaults to a taskless Thread; pass asTask true to create a Task in the same send. A top-level start may mention related Agents directly; in replies, only a Human can invite an unfollowed Agent. Pass Member refs in mentions and spell their handles inside the body; only mentioned Members render as mention chips. dm sends a private direct message to one enabled Agent Member in your Workspace: use it for quick clarifications and status syncs — never for task work, decisions, or anything that needs team visibility or traceability (use a Thread); if a DM exchange with the same Member exceeds about 3 exchanges, move it to a Thread, because every DM costs the recipient a full agent turn.',
+    description: 'Start a top-level Thread, reply to an existing Thread, or send a direct message (DM). Read the Thread first: a reply needs the current next-write token from a fully drained team_thread read (or your own last committed mutation), and unread work rejects before staleness is even checked — and a mention only delivers its Message and restores Attention, never the Thread\'s earlier facts, so entering a Thread whose facts have left your context means reading back through it first. start defaults to a taskless Thread; pass asTask true to create a Task in the same send. A top-level start may mention related Agents directly; in replies, only a Human can invite a Member the Thread has never carried. Mention by writing `@Handle` in body — the `@` is required, matching ignores case, and each named Member is delivered to and renders as a mention chip; `@all` reaches every Member of the Channel. Naming a Member this Thread has never carried still commits, delivers nothing to that Member, and reports them under undeliveredMentions: ask the Human to invite them, or reach them with a dm. dm sends a private direct message to one enabled Agent Member in your Workspace: use it for quick clarifications and status syncs — never for task work, decisions, or anything that needs team visibility or traceability (use a Thread); if a DM exchange with the same Member exceeds about 3 exchanges, move it to a Thread, because every DM costs the recipient a full agent turn.',
     parameters: {
         action: { type: 'string', required: true, enum: ['start', 'reply', 'dm'] },
         channelRef: { type: 'string', description: "Full branded Channel ref exactly as returned by Team tools, including the 'channel:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
@@ -356,8 +363,7 @@ const teamMessage = markAgentTeamPreset(defineTool({
         taskRef: { type: 'string', description: "Optional Task ref alias for reply on a Taskful Thread. Prefer threadRef; an unambiguous abbreviation of the first 6+ UUID hex characters also resolves." },
         memberRef: { type: 'string', description: "Full branded Member ref exactly as returned by Team tools, including the 'member:' prefix. An unambiguous abbreviation of the first 6+ UUID hex characters also resolves. Required for dm; the Member must be an enabled Agent in your Workspace (the Human cannot be DMed)." },
         asTask: { type: 'boolean', description: 'When true, start creates a Task with the Thread. Default false creates a taskless Thread.' },
-        body: { type: 'string', required: true, description: "Markdown body. Lead with the conclusion or state. Mention the Human only when they must know or decide, with a one-to-three-sentence opening and a `Decision needed: X (default: Y)` line when a decision is owed; mechanical detail follows below. Cite Team refs exactly as returned, as bare text with one colon (e.g. task:0f0a…) — never a double colon, never inside backticks or quotes. Unambiguous UUID abbreviations (first 6+ hex chars) also resolve. Spell each mentioned Member's handle in the prose so the mention renders inline." }, baseRevision: { type: 'number', description: "The next-write token from your latest fully drained team_thread read (or your own last committed mutation) on this Thread. Copy the explicitly rendered value verbatim; never increment, derive, compare, or cite it — it is an opaque concurrency token, not a fact about the Thread." },
-        mentions: { type: 'array', items: { type: 'string' }, description: 'Member refs to mention. Mentioned Agents receive the Message directly; write their handles in the body (any casing, optional @) so the mention renders inline.' },
+        body: { type: 'string', required: true, description: "Markdown body. Lead with the conclusion or state. Mention the Human only when they must know or decide; when a decision is owed, say plainly what needs deciding and what happens by default if nobody answers — no fixed template. Keep it the shortest useful message for the recipients; mechanical detail follows below. Cite Team refs exactly as returned, as bare text with one colon (e.g. task:0f0a…) — never a double colon, never inside backticks or quotes. Unambiguous UUID abbreviations (first 6+ hex chars) also resolve. Mention a Member by writing `@Handle` (`@` required, case-insensitive) in the prose: that is what delivers the Message to them and renders the mention chip, and `@all` reaches the whole Channel." }, baseRevision: { type: 'number', description: "The next-write token from your latest fully drained team_thread read (or your own last committed mutation) on this Thread. Copy the explicitly rendered value verbatim; never increment, derive, compare, or cite it — it is an opaque concurrency token, not a fact about the Thread." },
         attachments: { type: 'array', items: { type: 'string' }, description: 'Absolute file paths to share, e.g. screenshots or generated artifacts; images render as thumbnails for recipients. The Host validates each path and copies the file into the attachment cache, and members also receive one cached path per attachment; if any path fails validation the whole send is rejected.' },
     },
     output: {
@@ -365,6 +371,7 @@ const teamMessage = markAgentTeamPreset(defineTool({
                 kind: { type: 'string', required: true }, action: { type: 'string' }, taskRef: { type: 'string' }, threadRef: { type: 'string' }, revision: { type: 'number' },
                 expectedRevision: { type: 'number' }, messageRef: { type: 'string' }, memberIds: { type: 'array', items: { type: 'string' } }, unreadCount: { type: 'number' }, directCount: { type: 'number' },
                 recipientMemberId: { type: 'string' }, recipientHandle: { type: 'string' }, delivered: { type: 'boolean' }, deliveryNote: { type: 'string' }, occurredAt: { type: 'string' },
+                undeliveredMentions: { type: 'array', items: { type: 'string' } },
             } },
         render: (_args, value) => {
             if (value.kind === 'dm-sent') {
@@ -381,6 +388,9 @@ const teamMessage = markAgentTeamPreset(defineTool({
                             value.action === 'start' ? 'Committed — Thread created.' : 'Committed — reply added.',
                             [value.messageRef, value.threadRef, ...(value.taskRef === undefined ? [] : [value.taskRef])].join(' · '),
                             ...(value.occurredAt === undefined ? [] : [`Committed at ${formatTeamTimestamp(value.occurredAt)}`]),
+                            ...(value.undeliveredMentions === undefined || value.undeliveredMentions.length === 0 ? [] : [
+                                `Mention not delivered — ${value.undeliveredMentions.join(', ')} never took part in this Thread, so nothing reached them. Only a Human can invite a Member: reach them with a dm, or ask the Human.`,
+                            ]),
                             nextWriteLine(value.revision),
                         ].join('\n') }];
             }
@@ -400,7 +410,6 @@ const teamMessage = markAgentTeamPreset(defineTool({
             throw new Error('team_message requires an Agent session');
         const current = member(agent);
         const host = service(agent);
-        const mentions = args.mentions;
         const rawPaths = args.attachments;
         const attachmentPaths = Array.isArray(rawPaths) ? rawPaths.filter((entry) => typeof entry === 'string' && entry.trim() !== '') : undefined;
         const paths = attachmentPaths !== undefined && attachmentPaths.length > 0 ? { attachmentPaths } : {};
@@ -408,13 +417,13 @@ const teamMessage = markAgentTeamPreset(defineTool({
             if (args.channelRef === undefined || args.taskRef !== undefined || args.threadRef !== undefined || args.baseRevision !== undefined)
                 throw new Error('start requires channelRef and does not accept threadRef, taskRef, or baseRevision');
             const result = await host.sendMessageForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
-                channelRef: args.channelRef, body: args.body, asTask: args.asTask === true, ...(mentions === undefined ? {} : { recipients: mentions }), ...paths });
+                channelRef: args.channelRef, body: args.body, asTask: args.asTask === true, ...paths });
             return messageOutcome(result, 'start');
         }
         if (args.action === 'dm') {
             if (args.memberRef === undefined || args.channelRef !== undefined || args.threadRef !== undefined || args.taskRef !== undefined
-                || args.baseRevision !== undefined || args.asTask !== undefined || mentions !== undefined || attachmentPaths !== undefined) {
-                throw new Error('dm requires memberRef and body only; it does not accept channelRef, threadRef, taskRef, baseRevision, asTask, mentions, or attachments');
+                || args.baseRevision !== undefined || args.asTask !== undefined || attachmentPaths !== undefined) {
+                throw new Error('dm requires memberRef and body only; it does not accept channelRef, threadRef, taskRef, baseRevision, asTask, or attachments');
             }
             try {
                 const result = await host.dmForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
@@ -435,16 +444,20 @@ const teamMessage = markAgentTeamPreset(defineTool({
         const result = await host.replyForAgent(agent, { requestId: requestId(agent.id, exec.callId), workspaceId: current.workspaceId,
             ...(args.threadRef === undefined ? {} : { threadRef: args.threadRef }),
             ...(args.taskRef === undefined ? {} : { taskRef: args.taskRef }),
-            body: args.body, baseRevision,
-            ...(mentions === undefined ? {} : { recipients: mentions }), ...paths });
+            body: args.body, baseRevision, ...paths });
         return messageOutcome(result, 'reply');
     },
 }));
 function messageOutcome(result, action) {
-    if (result.kind === 'committed')
+    if (result.kind === 'committed') {
+        // A start always delivers to the Members it names — they begin following the
+        // new Thread — so only a reply can report names the Thread has never carried.
+        const undelivered = 'undeliveredMentions' in result ? result.undeliveredMentions : undefined;
         return { kind: result.kind, action, threadRef: result.thread.threadRef,
             ...(result.task === undefined ? {} : { taskRef: result.task.taskRef }),
-            revision: result.thread.revision, messageRef: result.message.messageRef, occurredAt: result.receipt.occurredAt };
+            revision: result.thread.revision, messageRef: result.message.messageRef, occurredAt: result.receipt.occurredAt,
+            ...(undelivered === undefined || undelivered.length === 0 ? {} : { undeliveredMentions: [...undelivered] }) };
+    }
     if (result.kind === 'member_not_following')
         return { kind: result.kind, memberIds: [...result.memberIds],
             ...(result.taskRef === undefined ? {} : { taskRef: result.taskRef }), ...(result.threadRef === undefined ? {} : { threadRef: result.threadRef, revision: result.revision }) };
@@ -604,7 +617,7 @@ const teamView = defineTool({
         return {
             channels: view.channels.map(channel => ({ channelRef: channel.channelRef, name: channel.name })),
             members: [
-                { memberId: view.humanMemberId, kind: 'human', handle: 'human', description: 'Human Team Member', presence: 'available' },
+                { memberId: view.humanMemberId, kind: 'human', handle: AGENT_TEAM_HUMAN_HANDLE, description: 'Human Team Member', presence: 'available' },
                 ...host.members().filter(status => visibleMemberIds.has(status.member.memberId)).map(status => ({ memberId: status.member.memberId,
                     kind: 'agent', handle: status.member.handle, description: status.member.description, presence: status.presence })),
             ],

package/packages/tool-agent-team/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAelD,eAAO,MAAM,IAAI,8BAA8B,CAAA;AAC/C,eAAO,MAAM,MAAM,UAAY,CAAA;AAupB/B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAOxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAelD,eAAO,MAAM,IAAI,8BAA8B,CAAA;AAC/C,eAAO,MAAM,MAAM,UAAY,CAAA;AAoqB/B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAOxC"}

package/packages/agent-team/lib/progress-nudge.js

@@ -1,328 +0,0 @@
-/**
- * Progress-visibility nudges: advisory Session notices that keep Member agents
- * reporting progress into their Threads. Two regimes over one shared
- * per-Member silent-tool-call counter:
- *
- * - Thread progress (A): a Member holding an active Claim, or following a
- *   taskless Thread, that has run many tool calls since its last committed
- *   public communication is reminded to post a brief update. The reminder
- *   ladder advances 20 → 40 → 60… per Member.
- * - Claim suggestion (B): a Member following a still-`todo` Task it has never
- *   claimed is reminded — once per (Member, Thread) within the current Member
- *   Session — that team_claim exists.
- *
- * The Coordinator owns counting, thresholds, notice formatting, dedupe,
- * in-flight revocation, and the deferred steer. It consumes only facts the
- * Host already holds: live `tool/call`/`user/message` session events in their
- * real `{type, seq, time, data}` envelope, the Session log for one-time
- * recovery, committed ledger operations, and a ledger-owned eligibility
- * projection (`progressNudgeTargets`). It never writes Team facts and never
- * wakes idle agents on its own — a nudge rides the member's next tool call.
- *
- * @module @wowyuarm/dsh-agent-team/progress-nudge
- */
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { AGENT_TEAM_PLUGIN_ID, isCheckpointContinuationMessage } from "./context-source.js";
-/** Notice summary for every nudge this Coordinator injects. */
-export const PROGRESS_NUDGE_NOTICE_SUMMARY = 'Progress visibility reminder';
-export const PROGRESS_NUDGE_TOOL_CALLS_START = 20;
-export const PROGRESS_NUDGE_TOOL_CALLS_STEP = 20;
-export const CLAIM_SUGGESTION_TOOL_CALLS = 5;
-/** Stable line prefix marking Claim-suggestion targets inside a nudge notice; the only text this module ever parses back. */
-const CLAIM_TARGET_LINE_PREFIX = '- Claim target: Task ';
-const CLAIM_TARGET_LINE = /^- Claim target: Task (task:[0-9a-f-]+) — Thread (thread:[0-9a-f-]+)$/;
-/** Ledger operation kinds that count as committed public communication and reset silence. */
-export function isPublicCommunicationOperationKind(kind) {
-    return kind === 'team/message-sent' || kind === 'team/thread-replied'
-        || kind === 'team/claim-created' || kind === 'team/claim-done' || kind === 'team/claim-released';
-}
-/** Whether one message is a nudge notice this module injected. */
-export function isProgressNudgeNotice(message) {
-    const source = message.source;
-    return source.kind === 'plugin' && source.plugin === AGENT_TEAM_PLUGIN_ID
-        && source.form === 'notice' && source.summary === PROGRESS_NUDGE_NOTICE_SUMMARY;
-}
-/**
- * Event-driven per-Member nudge state machine. All state is in-process and
- * scoped to one Member Session; nothing is persisted. The Host feeds it live
- * session events in their real envelope, committed operations, and lifecycle
- * stop points.
- */
-export class ProgressNudgeCoordinator {
-    members = new Map();
-    agentForMember;
-    targetsForMember;
-    sessionLogForMember;
-    log;
-    scheduleSteer;
-    progressThresholdStart;
-    progressThresholdStep;
-    claimSuggestionThreshold;
-    constructor(options) {
-        this.agentForMember = options.agentForMember;
-        this.targetsForMember = options.targetsForMember;
-        this.sessionLogForMember = options.sessionLogForMember;
-        this.log = options.log;
-        this.scheduleSteer = options.scheduleSteer ?? (run => { queueMicrotask(run); });
-        this.progressThresholdStart = options.progressThresholdStart ?? PROGRESS_NUDGE_TOOL_CALLS_START;
-        this.progressThresholdStep = options.progressThresholdStep ?? PROGRESS_NUDGE_TOOL_CALLS_STEP;
-        this.claimSuggestionThreshold = options.claimSuggestionThreshold ?? CLAIM_SUGGESTION_TOOL_CALLS;
-    }
-    /**
-     * One live session event for a Member, in its real `{type, seq, time, data}`
-     * envelope. Only `tool/call` counts toward silence; a `user/message` whose
-     * source is exactly this module's own notice records that the model consumed
-     * the nudge (a Claim suggestion becomes final only then). The live `agent`
-     * is passed in by the caller because it exists at event time even before
-     * the Host finishes publishing the handle.
-     */
-    onSessionEvent(memberId, sessionId, agent, event) {
-        if (event.type === 'user/message') {
-            if (!isProgressNudgeNotice(event.data))
-                return;
-            const state = this.members.get(memberId);
-            if (state === undefined)
-                return;
-            const notice = state.pending;
-            if (notice !== undefined && notice.messageId === event.data.id)
-                state.pending = undefined;
-            for (const threadRef of claimTargetThreadRefs(event.data))
-                state.claimSuggested.add(threadRef);
-            return;
-        }
-        if (event.type !== 'tool/call')
-            return;
-        let state = this.members.get(memberId);
-        if (state === undefined || state.sessionId !== sessionId) {
-            // First event of this Member Session (or a generation the Host did not
-            // stop explicitly): fresh tracking replaces whatever was there, and
-            // consumed one-time suggestions are recovered from the durable log so a
-            // Host restart or suspend/resume within the same Session cannot repeat
-            // them. A Human-initiated new Session has a different id and starts
-            // empty, exactly as specified.
-            this.dropState(memberId, state);
-            state = { sessionId, silentToolCalls: 0, nextProgressThreshold: this.progressThresholdStart,
-                claimSuggested: this.recoverClaimSuggestions(memberId, sessionId), };
-            this.members.set(memberId, state);
-        }
-        state.silentToolCalls += 1;
-        if (state.lastNudgeTurn === event.data.turn)
-            return;
-        this.maybeNudge(memberId, state, agent, event.data.turn);
-    }
-    /**
-     * One ledger operation committed. A Member actor's public communication
-     * resets its silence; every commit also reconciles pending notices whose
-     * targets may have just disappeared (Task accepted, Channel archived, the
-     * Claim taken by someone else).
-     */
-    onCommitted(operation) {
-        if (operation.actor.kind === 'member' && operation.actor.memberId !== undefined
-            && isPublicCommunicationOperationKind(operation.kind)) {
-            const state = this.members.get(operation.actor.memberId);
-            if (state !== undefined) {
-                state.silentToolCalls = 0;
-                state.nextProgressThreshold = this.progressThresholdStart;
-                this.revokePending(operation.actor.memberId, state);
-            }
-        }
-        this.reconcileAll();
-    }
-    /** Revoke one Member's queued-but-unconsumed nudge, e.g. when a higher-priority Team notice is injected. */
-    revokePendingNotice(memberId) {
-        const state = this.members.get(memberId);
-        if (state !== undefined)
-            this.revokePending(memberId, state);
-    }
-    /** Drop all tracking for one Member (suspend/archive/remove/renew/context-clear/steer failure). */
-    stopTracking(memberId) {
-        this.dropState(memberId, this.members.get(memberId));
-        this.members.delete(memberId);
-    }
-    /** Stop tracking every Member. */
-    dispose() {
-        for (const memberId of this.members.keys())
-            this.stopTracking(memberId);
-    }
-    /** Rebuild the consumed one-time suggestion set from this Session's durable log. */
-    recoverClaimSuggestions(memberId, sessionId) {
-        const suggested = new Set();
-        const log = this.sessionLogForMember(memberId, sessionId);
-        if (log === undefined)
-            return suggested;
-        for (const event of log.events) {
-            if (event.type !== 'user/message')
-                continue;
-            if (!isProgressNudgeNotice(event.data))
-                continue;
-            for (const threadRef of claimTargetThreadRefs(event.data))
-                suggested.add(threadRef);
-        }
-        return suggested;
-    }
-    dropState(memberId, state) {
-        if (state === undefined)
-            return;
-        this.revokePending(memberId, state);
-        this.members.delete(memberId);
-    }
-    revokePending(memberId, state) {
-        const notice = state.pending;
-        if (notice !== undefined) {
-            notice.canceled = true;
-            if (notice.steered) {
-                const agent = this.agentForMember(memberId);
-                const pending = agent === undefined ? undefined
-                    : [...agent.inbox.nextStep, ...agent.inbox.nextTurn].find(message => message.id === notice.messageId);
-                // A just-consumed notice is simply gone; remove() returning false is expected.
-                if (pending !== undefined)
-                    agent.inbox.remove(pending.id);
-            }
-        }
-        state.pending = undefined;
-    }
-    /** Re-check every live Member's pending notice against the targets it actually listed. */
-    reconcileAll() {
-        for (const [memberId, state] of this.members) {
-            const notice = state.pending;
-            if (notice === undefined)
-                continue;
-            const agent = this.agentForMember(memberId);
-            if (agent === undefined) {
-                this.dropState(memberId, state);
-                continue;
-            }
-            const targets = this.targetsForMember(memberId);
-            // The notice is stale when ANY target it listed is no longer eligible:
-            // the body names threads whose work may be finished, so a partial
-            // survival must not keep the whole stale notice alive.
-            const progressAlive = notice.progressThreadRefs.length === 0
-                || notice.progressThreadRefs.every(threadRef => targets.progress.some(target => target.threadRef === threadRef));
-            const claimAlive = notice.claimThreadRefs.length === 0
-                || notice.claimThreadRefs.every(threadRef => targets.claim.some(target => target.threadRef === threadRef));
-            if (!progressAlive || !claimAlive)
-                this.revokePending(memberId, state);
-        }
-    }
-    maybeNudge(memberId, state, agent, turn) {
-        const targets = this.targetsForMember(memberId);
-        const progressDue = state.silentToolCalls >= state.nextProgressThreshold && targets.progress.length > 0;
-        const freshClaimTargets = targets.claim
-            .filter(target => !state.claimSuggested.has(target.threadRef) && state.pending?.claimThreadRefs.includes(target.threadRef) !== true);
-        const claimDue = state.silentToolCalls >= this.claimSuggestionThreshold && freshClaimTargets.length > 0;
-        if (!progressDue && !claimDue)
-            return;
-        if (this.hasBlockingNotice(agent))
-            return;
-        const progressTargets = progressDue ? targets.progress : [];
-        const claimTargets = claimDue ? freshClaimTargets : [];
-        const notice = createUserMessage({
-            content: [{ type: 'text', text: nudgeNoticeText(state.silentToolCalls, progressTargets, claimTargets) }],
-            source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PROGRESS_NUDGE_NOTICE_SUMMARY },
-        });
-        const pending = {
-            messageId: notice.id,
-            progressThreadRefs: progressTargets.map(target => target.threadRef),
-            claimThreadRefs: claimTargets.map(target => target.threadRef),
-            steered: false,
-            canceled: false,
-        };
-        // Record intent first: the scheduled steer, its cancellation check, and
-        // its failure handling all live on this single PendingNotice object, so a
-        // revoke between queueing and the microtask leaves no orphan injection.
-        // lastNudgeTurn stays as the same-turn intent guard, but the A threshold
-        // only commits after the real steer succeeds — a canceled or failed
-        // schedule leaves the rung due so the next tool call retries it.
-        state.pending = pending;
-        state.lastNudgeTurn = turn;
-        this.scheduleSteer(() => {
-            if (pending.canceled)
-                return;
-            try {
-                agent.steer(notice);
-            }
-            catch (error) {
-                this.log?.(`progress nudge steer failed for member '${memberId}': ${error instanceof Error ? error.message : String(error)}`);
-                pending.canceled = true;
-                if (state.pending === pending)
-                    state.pending = undefined;
-                this.stopTracking(memberId);
-                return;
-            }
-            pending.steered = true;
-            if (pending.progressThreadRefs.length > 0) {
-                // Advance the ladder past the count at real success in one move: a
-                // long silence held back by higher-priority notices must not replay
-                // every skipped rung on successive tool calls after the blocker
-                // clears.
-                while (state.nextProgressThreshold <= state.silentToolCalls)
-                    state.nextProgressThreshold += this.progressThresholdStep;
-            }
-        });
-    }
-    /**
-     * Recovery, Inbox, and pre-compaction notices outrank a progress nudge. If
-     * one is already pending, this nudge stays due and retries on the next tool
-     * call; a DM relay is not a notice and never blocks.
-     */
-    hasBlockingNotice(agent) {
-        for (const message of [...agent.inbox.nextStep, ...agent.inbox.nextTurn]) {
-            const source = message.source;
-            if (source.kind !== 'plugin' || source.plugin !== AGENT_TEAM_PLUGIN_ID)
-                continue;
-            // A queued checkpoint continuation is a pending wake that outranks a
-            // nudge exactly as the notice families above do. It rides the snapshot
-            // form (it must carry its checkpoint ref in a section), so it cannot be
-            // recognized by the notice summary check below.
-            if (isCheckpointContinuationMessage(message))
-                return true;
-            if (source.form !== 'notice')
-                continue;
-            if (source.summary !== PROGRESS_NUDGE_NOTICE_SUMMARY)
-                return true;
-        }
-        return false;
-    }
-}
-/** Extract the threadRefs this module itself wrote as Claim targets in one notice. */
-function claimTargetThreadRefs(message) {
-    const refs = [];
-    for (const block of message.content) {
-        if (block.type !== 'text')
-            continue;
-        for (const line of block.text.split('\n')) {
-            const match = CLAIM_TARGET_LINE.exec(line);
-            if (match !== null)
-                refs.push(match[2]);
-        }
-    }
-    return refs;
-}
-function nudgeNoticeText(silentToolCalls, progress, claim) {
-    const sections = [];
-    if (progress.length > 0) {
-        sections.push([
-            'Progress visibility reminder',
-            '',
-            `You have made ${silentToolCalls} tool calls since your last visible Team update. Please briefly update the relevant Thread(s): what you confirmed, what remains, and any blocker. Read the Thread first if needed, then continue working.`,
-            '',
-            ...progress.map(target => target.reason === 'active-claim'
-                ? `- Task ${target.taskRef} — Thread ${target.threadRef}`
-                : `- Taskless Thread ${target.threadRef} (reply only if your current work relates to it)`),
-        ].join('\n'));
-    }
-    if (claim.length > 0) {
-        sections.push([
-            'Claim visibility reminder',
-            '',
-            'You have been working while following the Task(s) below, but you have never claimed a direction there.',
-            '',
-            ...claim.map(target => `${CLAIM_TARGET_LINE_PREFIX}${target.taskRef} — Thread ${target.threadRef}`),
-            '',
-            'If your current work belongs to one of these Tasks, briefly state your direction in its Thread and consider team_claim. If it does not, no action is required. This is advisory, not a claim requirement.',
-        ].join('\n'));
-    }
-    if (progress.length > 0)
-        sections.push('This is advisory; do not stop useful work merely to produce a long status report.');
-    return sections.join('\n\n');
-}

package/packages/agent-team/lib/types/progress-nudge.d.ts

@@ -1,136 +0,0 @@
-/**
- * Progress-visibility nudges: advisory Session notices that keep Member agents
- * reporting progress into their Threads. Two regimes over one shared
- * per-Member silent-tool-call counter:
- *
- * - Thread progress (A): a Member holding an active Claim, or following a
- *   taskless Thread, that has run many tool calls since its last committed
- *   public communication is reminded to post a brief update. The reminder
- *   ladder advances 20 → 40 → 60… per Member.
- * - Claim suggestion (B): a Member following a still-`todo` Task it has never
- *   claimed is reminded — once per (Member, Thread) within the current Member
- *   Session — that team_claim exists.
- *
- * The Coordinator owns counting, thresholds, notice formatting, dedupe,
- * in-flight revocation, and the deferred steer. It consumes only facts the
- * Host already holds: live `tool/call`/`user/message` session events in their
- * real `{type, seq, time, data}` envelope, the Session log for one-time
- * recovery, committed ledger operations, and a ledger-owned eligibility
- * projection (`progressNudgeTargets`). It never writes Team facts and never
- * wakes idle agents on its own — a nudge rides the member's next tool call.
- *
- * @module @wowyuarm/dsh-agent-team/progress-nudge
- */
-import { type UserMessage } from '@deepseek-ai/dsh-llm';
-import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
-import type { AgentTeamMemberId, AgentTeamProgressNudgeTargets } from './types.ts';
-/** Notice summary for every nudge this Coordinator injects. */
-export declare const PROGRESS_NUDGE_NOTICE_SUMMARY = "Progress visibility reminder";
-export declare const PROGRESS_NUDGE_TOOL_CALLS_START = 20;
-export declare const PROGRESS_NUDGE_TOOL_CALLS_STEP = 20;
-export declare const CLAIM_SUGGESTION_TOOL_CALLS = 5;
-/** Minimal Agent surface the Coordinator depends on; real Agents satisfy it, tests fake it. */
-export interface ProgressNudgeAgent {
-    readonly inbox: {
-        readonly nextStep: readonly UserMessage[];
-        readonly nextTurn: readonly UserMessage[];
-        remove(messageId: UserMessage['id']): boolean;
-    };
-    steer(message: UserMessage): void;
-}
-/**
- * Read-only view of one Session log used to recover consumed one-time Claim
- * suggestions when a Member Session's tracking is (re)established.
- */
-export interface ProgressNudgeSessionLog {
-    /** Durable events in sequence order; the real `Session.ownEvents()`. */
-    readonly events: readonly SessionEvent[];
-}
-/** Minimal operation fact the Coordinator consumes; the ledger's full record satisfies it structurally. */
-export interface ProgressNudgeOperation {
-    readonly actor: {
-        readonly kind: string;
-        readonly memberId?: AgentTeamMemberId | undefined;
-    };
-    readonly kind: string;
-}
-export interface ProgressNudgeCoordinatorOptions {
-    /** Live Agent lookup for revocation and injection. */
-    readonly agentForMember: (memberId: AgentTeamMemberId) => ProgressNudgeAgent | undefined;
-    /** Current eligibility projection from the ledger. */
-    readonly targetsForMember: (memberId: AgentTeamMemberId) => AgentTeamProgressNudgeTargets;
-    /** Durable Session log lookup for one-time recovery on (re)activation. */
-    readonly sessionLogForMember: (memberId: AgentTeamMemberId, sessionId: SessionId) => ProgressNudgeSessionLog | undefined;
-    /** Log one line when steer fails; the Host wires its logger. */
-    readonly log?: (message: string) => void;
-    /**
-     * Schedule the actual steer past an in-flight session append publication.
-     * The default defers one microtask; tests may substitute a synchronous or
-     * manually triggered scheduler. The callback runs the real steer.
-     */
-    readonly scheduleSteer?: (run: () => void) => void;
-    /** Initial ladder start; tests override to keep runs small. */
-    readonly progressThresholdStart?: number;
-    /** Ladder step; tests override to keep runs small. */
-    readonly progressThresholdStep?: number;
-    /** Claim-suggestion threshold; tests override to keep runs small. */
-    readonly claimSuggestionThreshold?: number;
-}
-/** Ledger operation kinds that count as committed public communication and reset silence. */
-export declare function isPublicCommunicationOperationKind(kind: string): boolean;
-/** Whether one message is a nudge notice this module injected. */
-export declare function isProgressNudgeNotice(message: UserMessage): boolean;
-/**
- * Event-driven per-Member nudge state machine. All state is in-process and
- * scoped to one Member Session; nothing is persisted. The Host feeds it live
- * session events in their real envelope, committed operations, and lifecycle
- * stop points.
- */
-export declare class ProgressNudgeCoordinator {
-    private readonly members;
-    private readonly agentForMember;
-    private readonly targetsForMember;
-    private readonly sessionLogForMember;
-    private readonly log;
-    private readonly scheduleSteer;
-    private readonly progressThresholdStart;
-    private readonly progressThresholdStep;
-    private readonly claimSuggestionThreshold;
-    constructor(options: ProgressNudgeCoordinatorOptions);
-    /**
-     * One live session event for a Member, in its real `{type, seq, time, data}`
-     * envelope. Only `tool/call` counts toward silence; a `user/message` whose
-     * source is exactly this module's own notice records that the model consumed
-     * the nudge (a Claim suggestion becomes final only then). The live `agent`
-     * is passed in by the caller because it exists at event time even before
-     * the Host finishes publishing the handle.
-     */
-    onSessionEvent(memberId: AgentTeamMemberId, sessionId: SessionId, agent: ProgressNudgeAgent, event: SessionEvent): void;
-    /**
-     * One ledger operation committed. A Member actor's public communication
-     * resets its silence; every commit also reconciles pending notices whose
-     * targets may have just disappeared (Task accepted, Channel archived, the
-     * Claim taken by someone else).
-     */
-    onCommitted(operation: ProgressNudgeOperation): void;
-    /** Revoke one Member's queued-but-unconsumed nudge, e.g. when a higher-priority Team notice is injected. */
-    revokePendingNotice(memberId: AgentTeamMemberId): void;
-    /** Drop all tracking for one Member (suspend/archive/remove/renew/context-clear/steer failure). */
-    stopTracking(memberId: AgentTeamMemberId): void;
-    /** Stop tracking every Member. */
-    dispose(): void;
-    /** Rebuild the consumed one-time suggestion set from this Session's durable log. */
-    private recoverClaimSuggestions;
-    private dropState;
-    private revokePending;
-    /** Re-check every live Member's pending notice against the targets it actually listed. */
-    private reconcileAll;
-    private maybeNudge;
-    /**
-     * Recovery, Inbox, and pre-compaction notices outrank a progress nudge. If
-     * one is already pending, this nudge stays due and retries on the next tool
-     * call; a DM relay is not a notice and never blocks.
-     */
-    private hasBlockingNotice;
-}
-//# sourceMappingURL=progress-nudge.d.ts.map

package/packages/agent-team/lib/types/progress-nudge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"progress-nudge.d.ts","sourceRoot":"","sources":["../../src/progress-nudge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,6BAA6B,EAAsB,MAAM,YAAY,CAAA;AAGtG,+DAA+D;AAC/D,eAAO,MAAM,6BAA6B,iCAAiC,CAAA;AAE3E,eAAO,MAAM,+BAA+B,KAAK,CAAA;AACjD,eAAO,MAAM,8BAA8B,KAAK,CAAA;AAChD,eAAO,MAAM,2BAA2B,IAAI,CAAA;AAK5C,+FAA+F;AAC/F,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAA;QACzC,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAA;QACzC,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,OAAO,CAAA;KAC9C,CAAA;IACD,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAA;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;CACzC;AAED,2GAA2G;AAC3G,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAA;KAAE,CAAA;IAC5F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,+BAA+B;IAC9C,sDAAsD;IACtD,QAAQ,CAAC,cAAc,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,kBAAkB,GAAG,SAAS,CAAA;IACxF,sDAAsD;IACtD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,6BAA6B,CAAA;IACzF,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,KAAK,uBAAuB,GAAG,SAAS,CAAA;IACxH,gEAAgE;IAChE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IAClD,+DAA+D;IAC/D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;IACxC,sDAAsD;IACtD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAA;IACvC,qEAAqE;IACrE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAA;CAC3C;AA2BD,6FAA6F;AAC7F,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxE;AAED,kEAAkE;AAClE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAInE;AAED;;;;;GAKG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiD;IACzE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmD;IAClF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAqD;IACtF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAwD;IAC5F,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyC;IAC7D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2B;IACzD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;IAC/C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAC9C,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAQ;gBAErC,OAAO,EAAE,+BAA+B;IAWpD;;;;;;;OAOG;IACH,cAAc,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IA6BvH;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,sBAAsB,GAAG,IAAI;IAapD,4GAA4G;IAC5G,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAKtD,mGAAmG;IACnG,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAK/C,kCAAkC;IAClC,OAAO,IAAI,IAAI;IAIf,oFAAoF;IACpF,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,aAAa;IAerB,0FAA0F;IAC1F,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,UAAU;IAmDlB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CAc1B"}

package/packages/client-agent-team/lib/types/client/TeamSettings.d.ts

@@ -1,3 +0,0 @@
-import type { TeamSettingsProps } from './slots.ts';
-export declare function TeamSettings({ wide, loadMemberGroups, t }: TeamSettingsProps): import("react").JSX.Element;
-//# sourceMappingURL=TeamSettings.d.ts.map

package/packages/client-agent-team/lib/types/client/TeamSettings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TeamSettings.d.ts","sourceRoot":"","sources":["../../../src/client/TeamSettings.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGnD,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,EAAE,EAAE,iBAAiB,+BAE5E"}

package/packages/client-agent-team/lib/types/client/TeamSettings.js

@@ -1,5 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { TeamMembersAction } from "./TeamMembersAction.js";
-export function TeamSettings({ wide, loadMemberGroups, t }) {
-    return _jsx(TeamMembersAction, { wide: wide, loadMemberGroups: loadMemberGroups, t: t });
-}