@wowyuarm/dsh-agent-team 0.1.6 → 0.1.8

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

@@ -40,9 +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 { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { isDeepStrictEqual } from 'node:util';
 import { Service } from '@deepseek-ai/cordis';
 import { installModelSelection } from '@deepseek-ai/dsh-agent';
@@ -50,26 +47,21 @@ 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 * as memberSkills from "./member-skills.js";
+import { AGENT_TEAM_TOOL_NAMES, deepCopyCapabilities, MemberRuntime } from "./member-runtime.js";
+import { ProgressNudgeCoordinator } from "./progress-nudge.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';
-/**
- * Read-only core skills shipped beside the preset (the meta skill first:
- * its description routes any skill-management work to itself). Resolved
- * from this module's emitted location so it follows the installed plugin,
- * like the preset roster's own root.
- */
-const BUNDLED_SKILLS_DIRECTORY = resolve(dirname(fileURLToPath(import.meta.url)), '../core-skills');
 const INBOX_NOTICE_SUMMARY = 'Team Inbox has unread work.';
 const RECOVERY_NOTICE_SUMMARY = 'Recovery: continue your interrupted work.';
 const ORPHANED_MEMBER_DIAGNOSTIC = 'Member preset composition was lost after a reload; its tools are unavailable. Resume rebuilds the member in place.';
@@ -82,27 +74,11 @@ function sameChangeScope(left, right) {
         return left.threadRef === right.threadRef;
     return false;
 }
-/** Copy a Remote-supplied capability overlay into owned frozen storage. */
-function deepCopyCapabilities(capabilities) {
-    const copyAllow = (allow) => allow === undefined ? {} : { allow: [...allow] };
-    return {
-        ...(capabilities.tools === undefined ? {} : { tools: copyAllow(capabilities.tools.allow) }),
-        ...(capabilities.skills === undefined ? {} : { skills: copyAllow(capabilities.skills.allow) }),
-    };
-}
 /** Mark the preset's `team_message` definition as an Agent Team consumer. */
 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
@@ -127,10 +103,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;
@@ -153,10 +131,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')];
@@ -176,10 +156,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);
@@ -208,12 +190,25 @@ let AgentTeam = (() => {
         domain = __runInitializers(this, _instanceExtraInitializers);
         ledger;
         handles = new Map();
+        /** Live Member per session id; drives the root session/event listener. */
+        memberBySessionId = new Map();
         /** Live selection refs let model edits take effect without disposing the Session. */
         modelSelections = new Map();
-        /** Live skill selection refs let capability edits re-filter the catalog without disposing the Session. */
-        skillSelections = new Map();
-        /** Per-Member private skill provider disposers; released with the Member's agent scope. */
-        skillProviderDisposals = 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
@@ -222,23 +217,7 @@ let AgentTeam = (() => {
          * stale keys.
          */
         memberFailures = new Map();
-        /**
-         * Live per-Member tool restriction disposers, mirroring modelSelections:
-         * activation registers, disposal paths release, edits swap at a turn
-         * boundary. Deliberate interface reservation: the restriction seam is the
-         * primitive future Runtime Revision manifests orchestrate — do not remove
-         * during cleanup.
-         */
-        memberRestrictions = new Map();
-        /**
-         * Runtime-derived capability warnings, recomputed at every activation (like
-         * memberFailures, keyed by Member and never persisted): persisted warnings
-         * would lie after a Host restart or a Harness upgrade renames tools.
-         */
-        capabilityWarnings = 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({
@@ -250,6 +229,22 @@ let AgentTeam = (() => {
                 this.ctx.logger.warn(`agent-team: member '${this.memberLabel(memberId)}' reached ${consecutiveFailures}/${RECOVERY_MAX_CONSECUTIVE_ERRORS} consecutive recoverable failures; leaving it in error for the operator`);
             },
         });
+        /**
+         * Advisory progress-visibility nudges. Purely in-process: the ledger owns
+         * eligibility, this coordinator owns counting and notices, and neither ever
+         * writes Team facts. See docs/team-collaboration.md for the regimes.
+         */
+        progressNudge = new ProgressNudgeCoordinator({
+            agentForMember: memberId => this.handles.get(memberId)?.agent,
+            targetsForMember: memberId => this.requireLedger().progressNudgeTargets(memberId),
+            sessionLogForMember: (memberId, sessionId) => {
+                const handle = this.handles.get(memberId);
+                if (handle === undefined || handle.agent.session.id !== sessionId)
+                    return undefined;
+                return { events: handle.agent.session.ownEvents() };
+            },
+            log: message => { this.ctx.logger.warn(message); },
+        });
         lifecycleTail = Promise.resolve();
         accepting = true;
         changeVersion = 0;
@@ -276,6 +271,10 @@ let AgentTeam = (() => {
                         content: [{ type: 'text', text: preCompactionNoticeText() }],
                         source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: PRE_COMPACTION_NOTICE_SUMMARY },
                     });
+                    // Persist-your-conclusions outranks a queued progress nudge.
+                    const member = this.memberForAgent(agent);
+                    if (member !== undefined)
+                        this.progressNudge.revokePendingNotice(member.memberId);
                     agent.steer(hint);
                 },
             });
@@ -319,10 +318,28 @@ let AgentTeam = (() => {
                     this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
                 }
             });
+            // Progress nudges count every `tool/call` of each Member Session. The
+            // store's dispatch carrier is untagged, so a scope-tagged listener inside
+            // the Agent setup would receive nothing; one root listener that maps the
+            // session id back to its Member is the seam that works (same shape as the
+            // `agent/status` listener above). The first turn of a freshly published
+            // Member cannot race this: `handles.set()` precedes the same activation
+            // continuation that publishes the Agent, so by the time any tool call
+            // streams, the map lookup succeeds.
+            this.ctx.on('session/event', (session, event) => {
+                const memberId = this.memberBySessionId.get(session.id);
+                if (memberId === undefined)
+                    return;
+                const handle = this.handles.get(memberId);
+                if (handle === undefined || handle.agent.session.id !== session.id)
+                    return;
+                this.progressNudge.onSessionEvent(memberId, session.id, handle.agent, event);
+            });
             const domain = await this.ctx.storageDomain.open(agentTeamDomainSpec);
             this.ctx.effect(() => async () => {
                 this.accepting = false;
                 this.recovery.dispose();
+                this.progressNudge.dispose();
                 await this.autoCompaction.dispose();
                 if (this.attachmentGcTimer !== undefined)
                     clearInterval(this.attachmentGcTimer);
@@ -332,14 +349,7 @@ let AgentTeam = (() => {
                 await Promise.all([...this.handles.values()].map(handle => handle.dispose()));
                 this.handles.clear();
                 this.modelSelections.clear();
-                this.skillSelections.clear();
-                for (const dispose of this.skillProviderDisposals.values())
-                    dispose();
-                this.skillProviderDisposals.clear();
-                for (const dispose of this.memberRestrictions.values())
-                    dispose();
-                this.memberRestrictions.clear();
-                this.capabilityWarnings.clear();
+                this.memberRuntime.disposeAll();
                 this.runningAgents.clear();
                 await domain.close();
             }, 'agentTeam.dispose');
@@ -357,7 +367,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. */
@@ -458,6 +468,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 () => {
@@ -583,12 +607,14 @@ let AgentTeam = (() => {
                 // Drop the old handle's transient state: pending recovery episodes and
                 // error markers belong to the disposed agent, not to the Member.
                 this.recovery.stopTracking(request.memberId);
+                // The fresh Session may re-earn one Claim suggestion per Thread; the
+                // old Session's one-shot records must not leak into it.
+                this.progressNudge.stopTracking(request.memberId);
+                this.memberBySessionId.delete(previousSessionId);
                 await active.dispose();
                 this.handles.delete(request.memberId);
                 this.modelSelections.delete(request.memberId);
-                this.skillSelections.delete(request.memberId);
-                this.releaseMemberToolPolicy(request.memberId);
-                this.releaseMemberSkillProvider(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
@@ -647,6 +673,9 @@ let AgentTeam = (() => {
                 if (this.isInboxNotice(pending))
                     handle.agent.inbox.remove(pending.id);
             }
+            // Recovery carries the concrete interrupted work; a queued progress nudge
+            // is stale next to it and must not survive as a second reminder.
+            this.progressNudge.revokePendingNotice(member.memberId);
             handle.agent.steer(hint);
         }
         /** Automatic-recovery wakeup; throwing tells the coordinator the target is gone. */
@@ -696,37 +725,15 @@ let AgentTeam = (() => {
          */
         async applyCapabilityEdit(active, stored) {
             const memberId = stored.memberId;
-            if (this.runningAgents.has(active.agent.id)) {
-                await new Promise(resolve => {
-                    const disposers = [];
-                    const settle = () => {
-                        for (const dispose of disposers.splice(0))
-                            dispose();
-                        resolve();
-                    };
-                    disposers.push(this.ctx.on('agent/status', (payload) => {
-                        if (payload.agent !== active.agent)
-                            return;
-                        // A turn that ends — clean idle or error — is the boundary; the
-                        // next step recomputes schemas from the new restriction.
-                        if (payload.status !== 'running')
-                            settle();
-                    }), 
-                    // Disposal (suspend/remove/reactivation) resolves the wait: the old
-                    // restriction went with the disposed scope, so only the ledger
-                    // intent remains to apply at the next activation.
-                    this.ctx.on('session/disposed', (session) => {
-                        if (session.id === active.agent.session.id)
-                            settle();
-                    }));
-                });
-                if (this.handles.get(memberId) !== active)
-                    return;
+            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.reapplyMemberToolPolicy(stored);
-            const skillSelection = this.skillSelections.get(memberId);
-            if (skillSelection !== undefined)
-                skillSelection.swap(stored.capabilities?.skills?.allow);
+            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) {
@@ -735,7 +742,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;
             });
         }
@@ -1068,7 +1091,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
@@ -1083,7 +1106,7 @@ let AgentTeam = (() => {
                 const skillSelection = { current: member.capabilities?.skills?.allow, swap: () => { } };
                 const setup = async (agentCtx) => {
                     await this.ctx.agentPresets.mount(agentCtx, member.presetId);
-                    this.applyMemberToolPolicy(agentCtx, member);
+                    this.memberRuntime.applyMemberToolPolicy(agentCtx, member);
                     this.validateMemberPreset(agentCtx);
                     installModelSelection(agentCtx, selected);
                     return {
@@ -1091,7 +1114,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');
                         },
                     };
@@ -1106,19 +1135,11 @@ let AgentTeam = (() => {
                         agentOptions,
                         setup,
                     });
-                // The Member-private skill provider registers on the created agent's
-                // exact scope layer (the traceable-service seam, like the tool
-                // restriction): bundled read-only core skills plus this Member's own
-                // private directory.
-                this.skillProviderDisposals.set(member.memberId, memberSkills.mountMemberSkillProvider(created.agent.ctx, {
-                    skillsDirectory: join(member.privateMemoryPath, 'skills'),
-                    bundledSkillsDirectory: BUNDLED_SKILLS_DIRECTORY,
-                    selection: skillSelection,
-                }));
+                this.memberRuntime.mountMemberSkillProvider(member, created.agent.ctx, skillSelection);
                 await workspace.attachSession(member.sessionId);
                 this.handles.set(member.memberId, created);
+                this.memberBySessionId.set(member.sessionId, member.memberId);
                 this.modelSelections.set(member.memberId, selected);
-                this.skillSelections.set(member.memberId, skillSelection);
                 this.clearMemberFailure(member.memberId, 'activation');
                 this.nameMemberSession(member, created.agent);
                 this.notifyMember(created.agent);
@@ -1127,9 +1148,7 @@ let AgentTeam = (() => {
             catch (error) {
                 await created?.dispose();
                 this.modelSelections.delete(member.memberId);
-                this.skillSelections.delete(member.memberId);
-                this.releaseMemberToolPolicy(member.memberId);
-                this.releaseMemberSkillProvider(member.memberId);
+                this.memberRuntime.forgetMember(member.memberId);
                 this.setMemberFailure(member.memberId, 'activation', error instanceof Error ? error.message : String(error));
             }
             finally {
@@ -1156,9 +1175,7 @@ let AgentTeam = (() => {
                 if (stale !== undefined) {
                     this.handles.delete(memberId);
                     this.modelSelections.delete(memberId);
-                    this.skillSelections.delete(memberId);
-                    this.releaseMemberToolPolicy(memberId);
-                    this.releaseMemberSkillProvider(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');
@@ -1199,99 +1216,11 @@ let AgentTeam = (() => {
             if (missing.length > 0)
                 throw new Error(`team-enabled preset is missing tools: ${missing.join(', ')}`);
         }
-        /**
-         * Apply one Member's persisted tool allow-list as a scoped restriction on
-         * the freshly composed preset surface, and derive activation-time warnings
-         * for entries the current tool surface no longer knows. Runs inside setup
-         * BEFORE validateMemberPreset so the validation observes the restricted
-         * view (the Host always unions the five Team tools over the configured
-         * list). Deliberate interface reservation: this restriction seam is the
-         * primitive future Runtime Revision manifests orchestrate — do not remove
-         * during cleanup.
-         */
-        applyMemberToolPolicy(agentCtx, member) {
-            const scope = scopeOf(agentCtx);
-            const configured = member.capabilities?.tools?.allow;
-            if (configured === undefined) {
-                this.capabilityWarnings.delete(member.memberId);
-                return;
-            }
-            // Drop names the current surface does not know rather than failing the
-            // activation: a Harness upgrade renaming a tool must not make the Member
-            // unavailable. The warning carries the known-name digest so a distant
-            // future reader can diagnose the drift.
-            const known = this.ctx.tools.schemas(scope).map(tool => tool.name);
-            const knownSet = new Set(known);
-            const dropped = configured.filter(name => !knownSet.has(name));
-            this.setCapabilityWarnings(member.memberId, dropped.map(name => ({ name, knownNames: known })));
-            const allow = [...new Set([...configured.filter(name => knownSet.has(name)), ...AGENT_TEAM_TOOL_NAMES])];
-            if (allow.length === 0)
-                return;
-            // tools.restrict() requires a scoped context and rejects names outside
-            // the inherited surface; both errors surface as this Member's activation
-            // failure without touching any other Member.
-            const dispose = agentCtx.tools.restrict({ allow });
-            this.memberRestrictions.set(member.memberId, dispose);
-        }
-        /** Swap a live Member's tool policy at a turn boundary: dispose the old restriction, apply the new. */
-        reapplyMemberToolPolicy(member) {
-            this.releaseMemberToolPolicy(member.memberId);
-            this.applyMemberToolPolicy(this.requireLiveMemberContext(member.memberId), member);
-        }
-        requireLiveMemberContext(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;
-        }
-        /** Release one Member's restriction disposer and warning state; safe to call twice. */
-        releaseMemberToolPolicy(memberId) {
-            const dispose = this.memberRestrictions.get(memberId);
-            if (dispose !== undefined) {
-                this.memberRestrictions.delete(memberId);
-                dispose();
-            }
-            this.capabilityWarnings.delete(memberId);
-        }
-        /** Release one Member's private skill provider; safe to call twice. */
-        releaseMemberSkillProvider(memberId) {
-            const dispose = this.skillProviderDisposals.get(memberId);
-            if (dispose === undefined)
-                return;
-            this.skillProviderDisposals.delete(memberId);
-            dispose();
-        }
-        setCapabilityWarnings(memberId, warnings) {
-            if (warnings.length === 0)
-                this.capabilityWarnings.delete(memberId);
-            else
-                this.capabilityWarnings.set(memberId, Object.freeze([...warnings]));
-        }
-        async initializePrivateMemory(path) {
-            await mkdir(join(path, 'notes'), { recursive: true });
-            // The Member-private skills directory starts empty; the per-Member
-            // provider scans exactly this root (default roots excluded).
-            await mkdir(join(path, 'skills'), { 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);
@@ -1308,7 +1237,7 @@ let AgentTeam = (() => {
                 return Object.freeze({ member, availability: 'active', presence: 'error', diagnostic: runtimeError });
             // Capability warnings are runtime-derived at activation (handles-scoped,
             // like failures): absent while capabilities resolve cleanly.
-            const capabilityWarnings = this.capabilityWarnings.get(member.memberId);
+            const capabilityWarnings = this.memberRuntime.capabilityWarningsFor(member.memberId);
             return Object.freeze({
                 member, availability: 'active', presence: handle.agent.status === 'running' ? 'working' : 'available',
                 ...(capabilityWarnings === undefined ? {} : { capabilityWarnings }),
@@ -1353,6 +1282,10 @@ let AgentTeam = (() => {
             }
             const ledger = this.requireLedger();
             this.emitChanged(ledger.changeScopesOf(operation));
+            // Nudge reconciliation precedes notifyMember: a committed reply both
+            // resets the author's silence and cancels any of its queued nudge before
+            // the Inbox notice (higher priority) is considered.
+            this.progressNudge.onCommitted(operation);
             for (const memberId of ledger.affectedMembersOf(operation)) {
                 const handle = this.handles.get(memberId);
                 if (handle !== undefined)
@@ -1391,6 +1324,9 @@ let AgentTeam = (() => {
             const existingInboxHint = pending.find(message => this.isInboxNotice(message));
             if (existingInboxHint !== undefined)
                 agent.inbox.remove(existingInboxHint.id);
+            // A durable Inbox notice outranks a queued progress nudge; revoke it so
+            // the model reads concrete unread work instead of a generic reminder.
+            this.progressNudge.revokePendingNotice(member.memberId);
             const hint = createUserMessage({
                 content: [{ type: 'text', text: this.notificationText(notifications, member.memberId) }],
                 source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: INBOX_NOTICE_SUMMARY },
@@ -1496,14 +1432,14 @@ let AgentTeam = (() => {
                 await handle.dispose();
                 this.handles.delete(memberId);
             }
+            this.memberBySessionId.delete(member.sessionId);
             this.modelSelections.delete(memberId);
-            this.skillSelections.delete(memberId);
-            this.releaseMemberToolPolicy(memberId);
-            this.releaseMemberSkillProvider(memberId);
+            this.memberRuntime.forgetMember(memberId);
             this.clearMemberFailure(memberId, 'activation');
         }
         clearMemberRecoveryState(member) {
             this.recovery.stopTracking(member.memberId);
+            this.progressNudge.stopTracking(member.memberId);
             this.clearMemberFailure(member.memberId, 'runtime');
             this.clearMemberNotificationState(member.memberId);
         }