@wowyuarm/dsh-agent-team 0.1.5 → 0.1.7

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

@@ -40,8 +40,6 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     done = true;
 };
 import { randomUUID } from 'node:crypto';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { Service } from '@deepseek-ai/cordis';
 import { installModelSelection } from '@deepseek-ai/dsh-agent';
@@ -49,15 +47,17 @@ import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { scopeOf } from '@deepseek-ai/dsh-scope';
 import { SessionId } from '@deepseek-ai/dsh-session';
-import { effectiveSandboxMode, setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
+import { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { ATTACHMENT_MAX_BYTES, attachmentPayloadPath, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
 import { acceptedTaskCompactionMembers, AutoCompactionCoordinator, PRE_COMPACTION_NOTICE_SUMMARY, preCompactionNoticeText } from "./auto-compaction.js";
 import { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
+import { AGENT_TEAM_TOOL_NAMES, deepCopyCapabilities, MemberRuntime } from "./member-runtime.js";
 import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_CONSECUTIVE_ERRORS } from "./recovery.js";
 import { agentTeamDomainSpec } from "./spec.js";
 export { agentTeamDomainSpec, agentTeamOperationSchema } from "./spec.js";
 export { AGENT_TEAM_HUMAN_MEMBER_ID, AGENT_TEAM_INITIALIZE_REQUEST_ID } from "./ledger.js";
+export { AGENT_TEAM_TOOL_NAMES } from "./member-runtime.js";
 /** Process-stable marker carried by the final Team message tool definition. */
 export const AGENT_TEAM_PRESET_MARKER = Symbol.for('@wowyuarm/dsh-agent-team.preset');
 const AGENT_TEAM_PLUGIN_ID = '@wowyuarm/dsh-agent-team';
@@ -78,14 +78,22 @@ export function markAgentTeamPreset(definition) {
     Object.defineProperty(definition, AGENT_TEAM_PRESET_MARKER, { value: true });
     return definition;
 }
-/** Model-facing capabilities every Team-enabled preset must publish. */
-export const AGENT_TEAM_TOOL_NAMES = Object.freeze([
-    'team_inbox',
-    'team_thread',
-    'team_message',
-    'team_claim',
-    'team_view',
-]);
+/**
+ * A DM was durably recorded but its session injection could not run (no live
+ * handle, or the wake itself failed). The recorded DM stays durable; the
+ * sender should not blindly retry — the recipient recovers it through its DM
+ * history once its session is live again.
+ */
+export class AgentTeamDmDeliveryError extends Error {
+    recipientMemberId;
+    recipientHandle;
+    constructor(recipientMemberId, recipientHandle, message) {
+        super(message);
+        this.recipientMemberId = recipientMemberId;
+        this.recipientHandle = recipientHandle;
+        this.name = 'AgentTeamDmDeliveryError';
+    }
+}
 let AgentTeam = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
@@ -94,10 +102,12 @@ let AgentTeam = (() => {
     let _changes_decorators;
     let _createChannel_decorators;
     let _updateChannel_decorators;
+    let _archiveChannel_decorators;
     let _addMember_decorators;
     let _recoverMember_decorators;
     let _clearMemberContext_decorators;
     let _updateMember_decorators;
+    let _archiveMember_decorators;
     let _changeTask_decorators;
     let _promoteThread_decorators;
     let _joinChannel_decorators;
@@ -120,10 +130,12 @@ let AgentTeam = (() => {
             _changes_decorators = [Remote('changes')];
             _createChannel_decorators = [Remote('createChannel')];
             _updateChannel_decorators = [Remote('updateChannel')];
+            _archiveChannel_decorators = [Remote('archiveChannel')];
             _addMember_decorators = [Remote('addMember')];
             _recoverMember_decorators = [Remote('recoverMember')];
             _clearMemberContext_decorators = [Remote('clearMemberContext')];
             _updateMember_decorators = [Remote('updateMember')];
+            _archiveMember_decorators = [Remote('archiveMember')];
             _changeTask_decorators = [Remote('changeTask')];
             _promoteThread_decorators = [Remote('promoteThread')];
             _joinChannel_decorators = [Remote('joinChannel')];
@@ -143,10 +155,12 @@ let AgentTeam = (() => {
             __esDecorate(this, null, _changes_decorators, { kind: "method", name: "changes", static: false, private: false, access: { has: obj => "changes" in obj, get: obj => obj.changes }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _createChannel_decorators, { kind: "method", name: "createChannel", static: false, private: false, access: { has: obj => "createChannel" in obj, get: obj => obj.createChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateChannel_decorators, { kind: "method", name: "updateChannel", static: false, private: false, access: { has: obj => "updateChannel" in obj, get: obj => obj.updateChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _archiveChannel_decorators, { kind: "method", name: "archiveChannel", static: false, private: false, access: { has: obj => "archiveChannel" in obj, get: obj => obj.archiveChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _addMember_decorators, { kind: "method", name: "addMember", static: false, private: false, access: { has: obj => "addMember" in obj, get: obj => obj.addMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _recoverMember_decorators, { kind: "method", name: "recoverMember", static: false, private: false, access: { has: obj => "recoverMember" in obj, get: obj => obj.recoverMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _clearMemberContext_decorators, { kind: "method", name: "clearMemberContext", static: false, private: false, access: { has: obj => "clearMemberContext" in obj, get: obj => obj.clearMemberContext }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _updateMember_decorators, { kind: "method", name: "updateMember", static: false, private: false, access: { has: obj => "updateMember" in obj, get: obj => obj.updateMember }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _archiveMember_decorators, { kind: "method", name: "archiveMember", static: false, private: false, access: { has: obj => "archiveMember" in obj, get: obj => obj.archiveMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _changeTask_decorators, { kind: "method", name: "changeTask", static: false, private: false, access: { has: obj => "changeTask" in obj, get: obj => obj.changeTask }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _promoteThread_decorators, { kind: "method", name: "promoteThread", static: false, private: false, access: { has: obj => "promoteThread" in obj, get: obj => obj.promoteThread }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _joinChannel_decorators, { kind: "method", name: "joinChannel", static: false, private: false, access: { has: obj => "joinChannel" in obj, get: obj => obj.joinChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -177,6 +191,21 @@ let AgentTeam = (() => {
         handles = new Map();
         /** Live selection refs let model edits take effect without disposing the Session. */
         modelSelections = new Map();
+        /** Agent ids with a turn in flight; restarts must wait for the boundary. */
+        runningAgents = new Set();
+        /** Per-Member runtime state: tool restrictions, skill mounts, warnings, private memory. */
+        memberRuntime = new MemberRuntime({
+            // Deferred field access: the constructor runs before `handles` is
+            // populated, so the resolver must dereference at call time.
+            ctx: this.ctx,
+            liveMemberContext: memberId => {
+                const handle = this.handles.get(memberId);
+                if (handle === undefined)
+                    throw new Error(`Agent Member '${this.memberLabel(memberId)}' has no live session for a tool-policy update`);
+                return handle.agent.ctx;
+            },
+            runningAgents: this.runningAgents,
+        });
         /**
          * Why one Member shows error presence, per failure source. Reads prefer
          * activation, then runtime, then compaction; slots clear independently, so
@@ -186,8 +215,6 @@ let AgentTeam = (() => {
          */
         memberFailures = new Map();
         autoCompaction;
-        /** Agent ids with a turn in flight; restarts must wait for the boundary. */
-        runningAgents = new Set();
         notifiedInbox = new Map();
         attachmentGcTimer;
         recovery = new RecoveryCoordinator({
@@ -281,6 +308,7 @@ let AgentTeam = (() => {
                 await Promise.all([...this.handles.values()].map(handle => handle.dispose()));
                 this.handles.clear();
                 this.modelSelections.clear();
+                this.memberRuntime.disposeAll();
                 this.runningAgents.clear();
                 await domain.close();
             }, 'agentTeam.dispose');
@@ -298,7 +326,7 @@ let AgentTeam = (() => {
                 if (member.state === 'enabled')
                     await this.activateMember(member, undefined, persistedSessions);
                 else if (member.state === 'inactive')
-                    await this.cleanupRemovedMember(member);
+                    await this.memberRuntime.cleanupRemovedMember(member);
             }
         }
         /** Resolve one exact live Agent to its durable Team Member; forks do not inherit identity. */
@@ -399,6 +427,20 @@ let AgentTeam = (() => {
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
+        /**
+         * Archive one Channel: hidden from every surface with all facts kept. Pure
+         * ledger projection change — Member sessions stay live (they may work in
+         * other Channels), every active Claim on the Channel's Threads releases,
+         * and affected Members' Attention clears.
+         */
+        async archiveChannel(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const result = await this.requireLedger().archiveChannel({ ...request, actor: agentTeamHumanActor() });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
         /** Create a durable Member and atomically grant its declared initial Channels. */
         async addMember(request) {
             return this.enqueueLifecycle(async () => {
@@ -413,6 +455,7 @@ let AgentTeam = (() => {
                     description: request.description,
                     presetId: request.presetId,
                     ...(request.model === undefined ? {} : { model: Object.freeze({ ...request.model }) }),
+                    ...(request.capabilities === undefined ? {} : { capabilities: Object.freeze(deepCopyCapabilities(request.capabilities)) }),
                     privateMemoryPath: dshHomePath('agent-team', 'members', memberId),
                     state: 'enabled',
                 });
@@ -526,6 +569,7 @@ let AgentTeam = (() => {
                 await active.dispose();
                 this.handles.delete(request.memberId);
                 this.modelSelections.delete(request.memberId);
+                this.memberRuntime.forgetMember(request.memberId);
                 this.clearMemberFailure(request.memberId, 'activation');
                 this.clearMemberNotificationState(request.memberId);
                 // The previous log survives on disk; archiving hides it from every
@@ -616,9 +660,33 @@ let AgentTeam = (() => {
                         throw new Error(`Agent Member '${stored.handle}' has no live model selection`);
                     selection.current = stored.model ?? this.ctx.agentDefaultModel.currentSelection();
                 }
+                if (active !== undefined && !isDeepStrictEqual(previous?.capabilities ?? undefined, stored.capabilities ?? undefined)) {
+                    await this.applyCapabilityEdit(active, stored);
+                }
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(stored) });
             });
         }
+        /**
+         * Live-apply a capability edit at a turn boundary: while the Agent runs, the
+         * current turn keeps its schemas and catalog; the swap happens once idle,
+         * so the next step recomputes schemas from the new restriction and the
+         * durable replacement skill catalog from the new selection, with the same
+         * Session and history surviving. Suspend/remove during the wait cancels
+         * the swap — the disposed handle released the old restriction already and
+         * no disposer leaks.
+         */
+        async applyCapabilityEdit(active, stored) {
+            const memberId = stored.memberId;
+            const waited = await this.memberRuntime.awaitTurnBoundary(active);
+            if (waited && this.handles.get(memberId) !== active) {
+                // The wait resolved because the old generation was disposed, not
+                // because the turn ended; the ledger intent applies at the next
+                // activation instead.
+                return;
+            }
+            this.memberRuntime.reapplyMemberToolPolicy(stored);
+            this.memberRuntime.swapSkillSelection(memberId, stored.capabilities?.skills?.allow);
+        }
         /** Irreversibly remove one Member, archive its Session, and delete its private namespace. */
         async removeMember(request) {
             return this.enqueueLifecycle(async () => {
@@ -626,7 +694,23 @@ let AgentTeam = (() => {
                 if (result.committed)
                     this.emitCommitted(result.value.receipt);
                 await this.disposeMemberSession(request.memberId, result.value.member);
-                await this.cleanupRemovedMember(result.value.member);
+                await this.memberRuntime.cleanupRemovedMember(result.value.member);
+                return result.value;
+            });
+        }
+        /**
+         * Archive one Member: commit the archival, stop its live session (disposal
+         * only — private memory and the Session log stay on disk for a future
+         * restore), and archive the Session from every grouping surface. Like
+         * removal, all active Claims release and the Member's Attention clears.
+         */
+        async archiveMember(request) {
+            return this.enqueueLifecycle(async () => {
+                const result = await this.requireLedger().archiveMember({ ...request, actor: agentTeamHumanActor() });
+                if (result.committed)
+                    this.emitCommitted(result.value.receipt);
+                await this.disposeMemberSession(request.memberId, result.value.member);
+                await this.ctx.workspaceRegistry.archiveSession(result.value.member.sessionId);
                 return result.value;
             });
         }
@@ -813,6 +897,49 @@ let AgentTeam = (() => {
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
+        /**
+         * Agent-only direct message: append the audit-only dm-sent operation, then
+         * inject the body into the recipient's live session. The ledger commit is
+         * the durable fact; the injection is a transient runtime effect, so a
+         * missing handle or a failed wake returns a structured delivery error while
+         * the recorded DM stays durable for the recipient's recovery path.
+         */
+        async dmForAgent(agent, request) {
+            const actor = this.memberCall(agent, request.workspaceId);
+            const result = await this.requireLedger().sendDm({ ...request, actor });
+            if (!result.committed)
+                return result.value;
+            this.emitCommitted(result.value.receipt);
+            const recipient = result.value.recipient;
+            const handle = this.handles.get(recipient.memberId);
+            if (handle === undefined) {
+                throw new AgentTeamDmDeliveryError(recipient.memberId, recipient.handle, `DM recorded but not delivered: Agent Member '${recipient.handle}' has no live session; it will find the message in its DM history after recovery`);
+            }
+            try {
+                const message = createUserMessage({
+                    content: [{ type: 'text', text: this.dmRelayText(agent, recipient, request.body.trim(), result.value.receipt.operationId) }],
+                    source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'relay' },
+                });
+                // An idle recipient gets one ordinary turn; a busy one is steered into
+                // its current turn — the same wake split subagent continuations use.
+                if (handle.agent.status === 'idle')
+                    handle.agent.followup(message);
+                else
+                    handle.agent.steer(message);
+            }
+            catch (error) {
+                throw new AgentTeamDmDeliveryError(recipient.memberId, recipient.handle, `DM recorded but not delivered: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return result.value;
+        }
+        /** Relay body: the DM itself plus one bounded line of adjacent context. */
+        dmRelayText(senderAgent, recipient, body, excluding) {
+            const sender = this.memberForAgent(senderAgent);
+            const prior = this.requireLedger().dmHistoryBetween(senderAgent.id, recipient.memberId, excluding);
+            const header = `Direct message from @${sender?.handle ?? 'a Team Member'}:`;
+            const context = prior === undefined ? '' : `\n\n[most recent prior DM between you: ${prior}]`;
+            return `${header}\n\n${body}${context}`;
+        }
         threadHistoryForAgent(agent, request) {
             const actor = this.memberActor(agent);
             this.requireAgentWorkspace(actor, request.workspaceId);
@@ -916,7 +1043,7 @@ let AgentTeam = (() => {
             try {
                 const workspace = this.requireWorkspace(member.workspaceId);
                 const workspacePath = knownWorkspacePath ?? workspace.path;
-                await this.initializePrivateMemory(member.privateMemoryPath);
+                await this.memberRuntime.initializePrivateMemory(member.privateMemoryPath);
                 const persisted = knownSessions !== undefined ? knownSessions.has(member.sessionId)
                     : (await this.ctx.sessionPersistence.list()).some(header => header.id === member.sessionId);
                 // AgentOptions declares only provider/model. Install the full selection
@@ -925,8 +1052,13 @@ let AgentTeam = (() => {
                 const selection = member.model ?? this.ctx.agentDefaultModel.currentSelection();
                 const agentOptions = { provider: selection.provider, model: selection.model };
                 const selected = { current: selection, assembled: undefined };
+                // Absent skills.allow loads every discovered private skill; a present
+                // allow-list filters the catalog by name through the live ref below.
+                // `swap` is bound by the provider at activation (no-op until then).
+                const skillSelection = { current: member.capabilities?.skills?.allow, swap: () => { } };
                 const setup = async (agentCtx) => {
                     await this.ctx.agentPresets.mount(agentCtx, member.presetId);
+                    this.memberRuntime.applyMemberToolPolicy(agentCtx, member);
                     this.validateMemberPreset(agentCtx);
                     installModelSelection(agentCtx, selected);
                     return {
@@ -934,7 +1066,13 @@ let AgentTeam = (() => {
                             const agent = agentCtx.agent;
                             if (agent === undefined)
                                 throw new Error('agent-team setup has no unpublished Agent');
-                            if (effectiveSandboxMode(agent.session.events) !== 'danger-full-access')
+                            // The member scope composes no sandbox-policy service (the preset
+                            // owns no sandbox row), so read the last logged mode straight from
+                            // the session log; `sandbox/mode` is log-only and never joins the
+                            // model-visible surface. Re-appending only when the effective mode
+                            // differs keeps resumed members from growing redundant events.
+                            const logged = agent.session.ownEvents().toReversed().find(event => event.type === 'sandbox/mode');
+                            if (logged?.data.mode !== 'danger-full-access')
                                 setSandboxMode(agent.session, 'danger-full-access');
                         },
                     };
@@ -949,6 +1087,7 @@ let AgentTeam = (() => {
                         agentOptions,
                         setup,
                     });
+                this.memberRuntime.mountMemberSkillProvider(member, created.agent.ctx, skillSelection);
                 await workspace.attachSession(member.sessionId);
                 this.handles.set(member.memberId, created);
                 this.modelSelections.set(member.memberId, selected);
@@ -960,6 +1099,7 @@ let AgentTeam = (() => {
             catch (error) {
                 await created?.dispose();
                 this.modelSelections.delete(member.memberId);
+                this.memberRuntime.forgetMember(member.memberId);
                 this.setMemberFailure(member.memberId, 'activation', error instanceof Error ? error.message : String(error));
             }
             finally {
@@ -986,6 +1126,7 @@ let AgentTeam = (() => {
                 if (stale !== undefined) {
                     this.handles.delete(memberId);
                     this.modelSelections.delete(memberId);
+                    this.memberRuntime.forgetMember(memberId);
                     // The composition-loss diagnostic this heal answers is stale once the
                     // rebuild starts; a later activation must not resurface it.
                     this.clearMemberFailure(memberId, 'compaction');
@@ -1026,28 +1167,11 @@ let AgentTeam = (() => {
             if (missing.length > 0)
                 throw new Error(`team-enabled preset is missing tools: ${missing.join(', ')}`);
         }
-        async initializePrivateMemory(path) {
-            await mkdir(join(path, 'notes'), { recursive: true });
-            try {
-                await writeFile(join(path, 'memory.md'), '# Member memory\n\n## Stable facts\n- Add only verified, durable facts that help future work.\n\n## Notes index\n- Add focused `notes/*.md` entries here when a reusable detail needs on-demand reading.\n', { flag: 'wx' });
-            }
-            catch (error) {
-                if (error.code !== 'EEXIST')
-                    throw error;
-            }
-        }
-        async cleanupRemovedMember(member) {
-            const results = await Promise.allSettled([
-                this.ctx.workspaceRegistry.archiveSession(member.sessionId),
-                rm(member.privateMemoryPath, { recursive: true, force: true }),
-            ]);
-            const failures = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
-            if (failures.length > 0)
-                throw new AggregateError(failures, `failed to clean up removed Member '${member.memberId}'`);
-        }
         memberStatus(member) {
             if (member.state === 'inactive')
                 return Object.freeze({ member, availability: 'inactive', presence: 'unavailable' });
+            if (member.state === 'archived')
+                return Object.freeze({ member, availability: 'archived', presence: 'unavailable' });
             if (member.state === 'suspended')
                 return Object.freeze({ member, availability: 'suspended', presence: 'unavailable' });
             const failures = this.memberFailures.get(member.memberId);
@@ -1062,7 +1186,13 @@ let AgentTeam = (() => {
             const runtimeError = failures?.runtime ?? failures?.compaction;
             if (runtimeError !== undefined)
                 return Object.freeze({ member, availability: 'active', presence: 'error', diagnostic: runtimeError });
-            return Object.freeze({ member, availability: 'active', presence: handle.agent.status === 'running' ? 'working' : 'available' });
+            // Capability warnings are runtime-derived at activation (handles-scoped,
+            // like failures): absent while capabilities resolve cleanly.
+            const capabilityWarnings = this.memberRuntime.capabilityWarningsFor(member.memberId);
+            return Object.freeze({
+                member, availability: 'active', presence: handle.agent.status === 'running' ? 'working' : 'available',
+                ...(capabilityWarnings === undefined ? {} : { capabilityWarnings }),
+            });
         }
         setMemberFailure(memberId, slot, message) {
             const failures = this.memberFailures.get(memberId) ?? {};
@@ -1247,6 +1377,7 @@ let AgentTeam = (() => {
                 this.handles.delete(memberId);
             }
             this.modelSelections.delete(memberId);
+            this.memberRuntime.forgetMember(memberId);
             this.clearMemberFailure(memberId, 'activation');
         }
         clearMemberRecoveryState(member) {