@wowyuarm/dsh-agent-team 0.1.2 → 0.1.3

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

@@ -51,14 +51,19 @@ import { scopeOf } from '@deepseek-ai/dsh-scope';
 import { SessionId } from '@deepseek-ai/dsh-session';
 import { effectiveSandboxMode, setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import { ATTACHMENT_MAX_BYTES, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
+import { ATTACHMENT_MAX_BYTES, attachmentPayloadPath, attachmentsRoot, copyPathAttachment, newAttachmentId, readAttachment, sanitizeMediaType, sweepAttachmentCache, validatePathAttachment, writeAttachment } from "./attachments.js";
+import { acceptedTaskCompactionMembers, AutoCompactionCoordinator } from "./auto-compaction.js";
 import { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
-import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_ATTEMPTS } from "./recovery.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";
 /** 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';
+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.';
 function sameChangeScope(left, right) {
     if (left.kind === 'workspace' && right.kind === 'workspace')
         return left.workspaceId === right.workspaceId;
@@ -166,19 +171,26 @@ let AgentTeam = (() => {
         handles = new Map();
         /** Live selection refs let model edits take effect without disposing the Session. */
         modelSelections = new Map();
-        diagnostics = new Map();
-        runtimeErrors = new Map();
+        /**
+         * Why one Member shows error presence, per failure source. Reads prefer
+         * activation, then runtime, then compaction; slots clear independently, so
+         * a recovered runtime error re-reveals an outstanding compaction failure.
+         * Keyed by Member rather than Session so a restarted Session cannot leak
+         * stale keys.
+         */
+        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({
-            inject: (memberId, attempt, kind) => {
-                this.ctx.logger.info(`agent-team: automatic recovery steering member '${this.memberLabel(memberId)}' (attempt ${attempt}/${RECOVERY_MAX_ATTEMPTS}, ${kind})`);
-                this.injectRecovery(memberId, attempt, kind);
+            wake: memberId => {
+                this.ctx.logger.info(`agent-team: automatic recovery wakeup for member '${this.memberLabel(memberId)}' after consecutive recoverable failures`);
+                this.injectRecovery(memberId);
             },
-            onStandDown: (memberId, attempts) => {
-                this.ctx.logger.warn(`agent-team: member '${this.memberLabel(memberId)}' still failing after ${attempts} automatic recovery attempts; leaving it in error for the operator`);
+            onStandDown: (memberId, consecutiveFailures) => {
+                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`);
             },
         });
         lifecycleTail = Promise.resolve();
@@ -187,6 +199,21 @@ let AgentTeam = (() => {
         changeWaiters = new Set();
         constructor(ctx) {
             super(ctx, 'agentTeam');
+            this.autoCompaction = new AutoCompactionCoordinator({
+                agentForMember: memberId => this.handles.get(memberId)?.agent,
+                compactionForAgent: agent => this.ctx.agentPresets.serviceFor(agent, 'compaction'),
+                reactivate: memberId => this.reactivateMember(memberId),
+                failed: (memberId, _sessionId, diagnostic) => {
+                    this.setMemberFailure(memberId, 'compaction', diagnostic);
+                    this.emitAutoCompactionChanged(memberId);
+                },
+                cleared: memberId => {
+                    if (!this.clearMemberFailure(memberId, 'compaction'))
+                        return;
+                    this.emitAutoCompactionChanged(memberId);
+                },
+                log: message => { this.ctx.logger.warn(`agent-team: ${message}`); },
+            });
         }
         /** Open the durable ledger and restore every enabled Member independently. */
         async [Service.init]() {
@@ -195,10 +222,10 @@ let AgentTeam = (() => {
                 if (member === undefined)
                     return;
                 const message = error instanceof Error ? error.message : String(error);
-                this.runtimeErrors.set(agent.id, message);
+                this.setMemberFailure(member.memberId, 'runtime', message);
                 const kind = classifyRecoverableError(message);
                 if (kind !== undefined)
-                    this.ctx.logger.warn(`agent-team: member '${member.handle}' hit a recoverable error (${kind}); automatic recovery scheduled`);
+                    this.ctx.logger.warn(`agent-team: member '${member.handle}' hit a recoverable ${kind} error; recording a consecutive error occurrence`);
                 this.recovery.onError(member.memberId, message);
                 this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
             });
@@ -209,14 +236,14 @@ let AgentTeam = (() => {
                 else
                     this.runningAgents.delete(agent.id);
                 if (status === 'running' && member !== undefined) {
-                    const recovered = this.runtimeErrors.delete(agent.id);
+                    const recovered = this.clearMemberFailure(member.memberId, 'runtime');
                     if (recovered)
                         this.notifiedInbox.delete(member.memberId);
                     this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
                     this.notifyMember(agent);
                 }
                 // A turn that ends without an error closes any automatic recovery episode.
-                if (status === 'idle' && member !== undefined && !this.runtimeErrors.has(agent.id)) {
+                if (status === 'idle' && member !== undefined && this.memberFailures.get(member.memberId)?.runtime === undefined) {
                     this.recovery.onCleanTurnEnd(member.memberId);
                 }
             });
@@ -224,6 +251,7 @@ let AgentTeam = (() => {
             this.ctx.effect(() => async () => {
                 this.accepting = false;
                 this.recovery.dispose();
+                await this.autoCompaction.dispose();
                 if (this.attachmentGcTimer !== undefined)
                     clearInterval(this.attachmentGcTimer);
                 this.attachmentGcTimer = undefined;
@@ -264,7 +292,6 @@ let AgentTeam = (() => {
         members() {
             return this.requireLedger().listMembers().map(member => this.memberStatus(member));
         }
-        /** Return only this Workspace's current Member projection to the Client. */
         /** Read-only navigation lookup for branded Task refs found in message bodies. */
         resolveTaskRefs(request) {
             this.requireWorkspace(request.workspaceId);
@@ -277,6 +304,7 @@ let AgentTeam = (() => {
             });
             return Object.freeze({ resolved: Object.freeze(this.requireLedger().resolveTaskRefs(request.workspaceId, taskRefs)) });
         }
+        /** Return only this Workspace's current Member projection to the Client. */
         membersForClient(request) {
             this.requireWorkspace(request.workspaceId);
             return this.members()
@@ -382,14 +410,7 @@ let AgentTeam = (() => {
                 const result = await this.requireLedger().suspendMember({ ...request, actor: agentTeamHumanActor() });
                 if (result.committed)
                     this.emitCommitted(result.value.receipt);
-                const handle = this.handles.get(request.memberId);
-                if (handle !== undefined) {
-                    await handle.dispose();
-                    this.handles.delete(request.memberId);
-                }
-                this.modelSelections.delete(request.memberId);
-                this.diagnostics.delete(request.memberId);
-                this.clearMemberNotificationState(request.memberId);
+                await this.disposeMemberSession(request.memberId, result.value.member);
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
             });
         }
@@ -414,11 +435,17 @@ let AgentTeam = (() => {
             const member = this.requireLedger().getMember(request.memberId);
             if (member === undefined || member.workspaceId !== request.workspaceId)
                 throw new Error(`unknown Member '${request.memberId}' in workspace '${request.workspaceId}'`);
-            const storedError = this.storedErrorFor(member.memberId);
             this.recovery.stopTracking(request.memberId);
-            const kind = classifyRecoverableError(storedError ?? '');
+            // An orphaned composition cannot be steered: its tools are gone, so a
+            // continuation prompt reaches an inert Member. Rebuild the Agent in place.
+            const handle = this.handles.get(request.memberId);
+            if (handle !== undefined && this.ctx.agentPresets.composedPreset(handle.agent.ctx) === undefined) {
+                this.ctx.logger.info(`agent-team: rebuilding member '${member.handle}' after its preset composition was orphaned by a reload`);
+                await this.reactivateMember(request.memberId);
+                return Object.freeze({ status: this.memberStatus(member) });
+            }
             this.ctx.logger.info(`agent-team: operator asked member '${member.handle}' to resume`);
-            this.steerResume(member, this.resumeText(kind ?? 'unspecified failure', { operatorRequested: true }));
+            this.steerResume(member, this.manualResumeText());
             return Object.freeze({ status: this.memberStatus(member) });
         }
         /** Ledger handle for log lines; falls back to the raw id when unknown. */
@@ -439,26 +466,11 @@ let AgentTeam = (() => {
             this.attachmentGcTimer = setInterval(() => { void sweep(); }, 24 * 60 * 60 * 1000);
             this.attachmentGcTimer.unref?.();
         }
-        /** Latest runtime error summary for a Member's live session, if any. */
-        storedErrorFor(memberId) {
-            const handle = this.handles.get(memberId);
-            if (handle === undefined)
-                return undefined;
-            return this.runtimeErrors.get(handle.agent.id);
+        automaticResumeText() {
+            return 'Your previous turn ended early due to a temporary service error. Please continue the work you were doing before the error.';
         }
-        /**
-         * Continuation prompt per the recovery design: name the error family,
-         * annotate automatic attempts, and on the final attempt ask for a graceful
-         * handoff instead of another crash.
-         */
-        resumeText(kindLabel, options) {
-            const opening = options?.operatorRequested === true ? 'The operator asked you to resume. ' : '';
-            const attemptNote = options?.attempt === undefined ? '' : ` (automatic recovery, attempt ${options.attempt}/${RECOVERY_MAX_ATTEMPTS})`;
-            let text = `${opening}Your previous turn ended early due to an error (${kindLabel})${attemptNote}. Please continue your work from where it stopped.`;
-            if (options?.attempt === RECOVERY_MAX_ATTEMPTS) {
-                text += ' If the same error recurs, stop and leave a short handoff note for the operator.';
-            }
-            return text;
+        manualResumeText() {
+            return 'The operator asked you to resume after the previous turn ended early. Please continue the work you were doing before the error.';
         }
         /**
          * Steer one continuation message into a Member's live session. Throws when
@@ -473,18 +485,22 @@ let AgentTeam = (() => {
             const body = notifications.length === 0 ? text : `${text}\n\n${this.notificationText(notifications, member.memberId)}`;
             const hint = createUserMessage({
                 content: [{ type: 'text', text: body }],
-                source: { kind: 'plugin', plugin: '@wowyuarm/dsh-agent-team', form: 'notice', summary: 'Recovery: continue your interrupted work.' },
+                source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: RECOVERY_NOTICE_SUMMARY },
             });
+            for (const pending of [...handle.agent.inbox.nextStep, ...handle.agent.inbox.nextTurn]) {
+                if (this.isInboxNotice(pending))
+                    handle.agent.inbox.remove(pending.id);
+            }
             handle.agent.steer(hint);
         }
-        /** Automatic-recovery injection; throwing tells the coordinator the target is gone. */
-        injectRecovery(memberId, attempt, kind) {
+        /** Automatic-recovery wakeup; throwing tells the coordinator the target is gone. */
+        injectRecovery(memberId) {
             const handle = this.handles.get(memberId);
             const agent = handle?.agent;
             const member = agent !== undefined ? this.memberForAgent(agent) : undefined;
             if (agent === undefined || member === undefined || member.state !== 'enabled')
                 throw new Error(`member '${memberId}' cannot be recovered automatically`);
-            this.steerResume(member, this.resumeText(kind, { attempt }));
+            this.steerResume(member, this.automaticResumeText());
         }
         /**
          * Human edit of one Member's mutable facts. A live model selection is
@@ -516,14 +532,7 @@ let AgentTeam = (() => {
                 const result = await this.requireLedger().removeMember({ ...request, actor: agentTeamHumanActor() });
                 if (result.committed)
                     this.emitCommitted(result.value.receipt);
-                const handle = this.handles.get(request.memberId);
-                if (handle !== undefined) {
-                    await handle.dispose();
-                    this.handles.delete(request.memberId);
-                }
-                this.modelSelections.delete(request.memberId);
-                this.diagnostics.delete(request.memberId);
-                this.clearMemberNotificationState(request.memberId);
+                await this.disposeMemberSession(request.memberId, result.value.member);
                 await this.cleanupRemovedMember(result.value.member);
                 return result.value;
             });
@@ -538,37 +547,26 @@ let AgentTeam = (() => {
         }
         /** Human-only Channel membership grant; it never injects historical Thread bodies. */
         async joinChannel(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
+            const actor = this.humanCall(request.workspaceId);
             const ledger = this.requireLedger();
             if (!ledger.hasCommitted(request.requestId))
                 this.assertChannelMembersAvailable([request.memberId]);
-            const result = await ledger.joinChannel({ ...request, actor: agentTeamHumanActor() });
+            const result = await ledger.joinChannel({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
         /** Human-only Channel membership removal and Channel-scoped cleanup. */
         async removeChannelMember(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
-            const result = await this.requireLedger().removeChannelMember({ ...request, actor: agentTeamHumanActor() });
+            const actor = this.humanCall(request.workspaceId);
+            const result = await this.requireLedger().removeChannelMember({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
             return result.value;
         }
         /** Human top-level Task creation; unfollowed Agent mentions use the two-send result. */
         async sendMessage(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
-            const metadata = await this.resolveMessageAttachments(request);
-            const result = await this.requireLedger().sendMessage({
-                ...request, body: this.appendAttachmentLines(request.body, metadata),
-                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
-                actor: agentTeamHumanActor(),
-            });
-            this.emitCommittedOutcome(result);
-            return result.value;
+            return this.sendMessageAs(this.humanCall(request.workspaceId), request);
         }
         /**
          * Resolve uploaded ids and agent-supplied absolute paths into one attachment
@@ -606,7 +604,7 @@ let AgentTeam = (() => {
             const trimmed = body.trim();
             if (metadata.length === 0)
                 return trimmed;
-            const lines = metadata.map(attachment => `[attachment] ${dshHomePath('agent-team', 'attachments', 'v1', attachment.attachmentId, attachment.name)}`);
+            const lines = metadata.map(attachment => `[attachment] ${attachmentPayloadPath(attachment.attachmentId, attachment.name)}`);
             return `${trimmed}\n${lines.join('\n')}`;
         }
         /** Upload one composer attachment into the cache; bytes are immutable once written. */
@@ -631,22 +629,12 @@ let AgentTeam = (() => {
         }
         /** Human existing-Thread reply; unread and revision conflicts are business outcomes. */
         async reply(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
-            const metadata = await this.resolveMessageAttachments(request);
-            const result = await this.requireLedger().reply({
-                ...request, body: this.appendAttachmentLines(request.body, metadata),
-                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
-                actor: agentTeamHumanActor(),
-            });
-            this.emitCommittedOutcome(result);
-            return result.value;
+            return this.replyAs(this.humanCall(request.workspaceId), request);
         }
         /** Human's personal Attention operation. */
         async changeAttention(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
-            const result = await this.requireLedger().changeAttention({ ...request, actor: agentTeamHumanActor() });
+            const actor = this.humanCall(request.workspaceId);
+            const result = await this.requireLedger().changeAttention({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
             return result.value;
@@ -658,9 +646,8 @@ let AgentTeam = (() => {
         }
         /** Human's durable, atomically acknowledged Thread read. */
         async readThread(request) {
-            this.requireAccepting();
-            this.requireWorkspace(request.workspaceId);
-            const result = await this.requireLedger().readThread({ ...request, actor: agentTeamHumanActor() });
+            const actor = this.humanCall(request.workspaceId);
+            const result = await this.requireLedger().readThread({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
             return result.value;
@@ -682,37 +669,15 @@ let AgentTeam = (() => {
         }
         /** Agent-only top-level Task creation. Workspace identity is verified against the live binding. */
         async sendMessageForAgent(agent, request) {
-            this.requireAccepting();
-            const actor = this.memberActor(agent);
-            this.requireAgentWorkspace(actor, request.workspaceId);
-            const metadata = await this.resolveMessageAttachments(request);
-            const result = await this.requireLedger().sendMessage({
-                ...request, body: this.appendAttachmentLines(request.body, metadata),
-                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
-                actor,
-            });
-            this.emitCommittedOutcome(result);
-            return result.value;
+            return this.sendMessageAs(this.memberCall(agent, request.workspaceId), request);
         }
         /** Agent-only existing-Thread reply. */
         async replyForAgent(agent, request) {
-            this.requireAccepting();
-            const actor = this.memberActor(agent);
-            this.requireAgentWorkspace(actor, request.workspaceId);
-            const metadata = await this.resolveMessageAttachments(request);
-            const result = await this.requireLedger().reply({
-                ...request, body: this.appendAttachmentLines(request.body, metadata),
-                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
-                actor,
-            });
-            this.emitCommittedOutcome(result);
-            return result.value;
+            return this.replyAs(this.memberCall(agent, request.workspaceId), request);
         }
         /** Agent-only personal Attention change. */
         async changeAttentionForAgent(agent, request) {
-            this.requireAccepting();
-            const actor = this.memberActor(agent);
-            this.requireAgentWorkspace(actor, request.workspaceId);
+            const actor = this.memberCall(agent, request.workspaceId);
             const result = await this.requireLedger().changeAttention({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
@@ -725,9 +690,7 @@ let AgentTeam = (() => {
         }
         /** Agent-only Claim mutation. */
         async changeClaimForAgent(agent, request) {
-            this.requireAccepting();
-            const actor = this.memberActor(agent);
-            this.requireAgentWorkspace(actor, request.workspaceId);
+            const actor = this.memberCall(agent, request.workspaceId);
             const result = await this.requireLedger().changeClaim({ ...request, actor });
             this.emitCommittedOutcome(result);
             return result.value;
@@ -743,9 +706,7 @@ let AgentTeam = (() => {
             return this.requireLedger().inbox(actor, request);
         }
         async readThreadForAgent(agent, request) {
-            this.requireAccepting();
-            const actor = this.memberActor(agent);
-            this.requireAgentWorkspace(actor, request.workspaceId);
+            const actor = this.memberCall(agent, request.workspaceId);
             const result = await this.requireLedger().readThread({ ...request, actor });
             if (result.committed)
                 this.emitCommitted(result.value.receipt);
@@ -782,6 +743,41 @@ let AgentTeam = (() => {
                     throw new Error(`Agent Member '${memberId}' is not available for Channel membership`);
             }
         }
+        /** Shared Task-creation commit: resolve uploads into metadata lines and append through the ledger. */
+        async sendMessageAs(actor, request) {
+            const metadata = await this.resolveMessageAttachments(request);
+            const result = await this.requireLedger().sendMessage({
+                ...request, body: this.appendAttachmentLines(request.body, metadata),
+                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
+                actor,
+            });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Shared existing-Thread reply commit: same upload resolution and outcome emission. */
+        async replyAs(actor, request) {
+            const metadata = await this.resolveMessageAttachments(request);
+            const result = await this.requireLedger().reply({
+                ...request, body: this.appendAttachmentLines(request.body, metadata),
+                ...(metadata.length === 0 ? {} : { resolvedAttachments: metadata }),
+                actor,
+            });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Fence one Human Remote call: accepting Host, known Workspace, Human actor. */
+        humanCall(workspaceId) {
+            this.requireAccepting();
+            this.requireWorkspace(workspaceId);
+            return agentTeamHumanActor();
+        }
+        /** Fence one Member call: accepting Host, live Member binding, matching Workspace. */
+        memberCall(agent, workspaceId) {
+            this.requireAccepting();
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, workspaceId);
+            return actor;
+        }
         memberActor(agent) {
             const member = this.memberForAgent(agent);
             if (member === undefined)
@@ -853,20 +849,50 @@ let AgentTeam = (() => {
                 await workspace.attachSession(member.sessionId);
                 this.handles.set(member.memberId, created);
                 this.modelSelections.set(member.memberId, selected);
-                this.diagnostics.delete(member.memberId);
+                this.clearMemberFailure(member.memberId, 'activation');
                 this.nameMemberSession(member, created.agent);
                 this.notifyMember(created.agent);
+                this.autoCompaction.activated(member.memberId);
             }
             catch (error) {
                 await created?.dispose();
                 this.modelSelections.delete(member.memberId);
-                this.diagnostics.set(member.memberId, error instanceof Error ? error.message : String(error));
+                this.setMemberFailure(member.memberId, 'activation', error instanceof Error ? error.message : String(error));
             }
             finally {
                 // Activation only changes this Workspace's presence projection.
                 this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
             }
         }
+        /**
+         * Rebuild one enabled Member in place from its persisted Session.
+         *
+         * A bundle-row reload tears down the preset roster subtree, which prunes the
+         * standing mount while live agents keep their dead scope bindings: the
+         * Member keeps its session but loses its composed tools and services.
+         * Re-running the preset composition requires a fresh Agent, and disposal is
+         * the cost — the Web Client marks the recreated Session unavailable until it
+         * is reopened, the same trade the shipped suspend/resume cycle makes.
+         */
+        reactivateMember(memberId) {
+            return this.enqueueLifecycle(async () => {
+                const member = this.requireLedger().getMember(memberId);
+                if (member === undefined || member.state !== 'enabled')
+                    return false;
+                const stale = this.handles.get(memberId);
+                if (stale !== undefined) {
+                    this.handles.delete(memberId);
+                    this.modelSelections.delete(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');
+                    this.emitAutoCompactionChanged(memberId);
+                    await stale.dispose();
+                }
+                await this.activateMember(member);
+                return this.handles.has(memberId);
+            });
+        }
         /**
          * Default an untitled Member Session to its handle so the ordinary Session
          * list names it. An explicit rename or any earlier title always wins; the
@@ -921,17 +947,35 @@ let AgentTeam = (() => {
                 return Object.freeze({ member, availability: 'inactive', presence: 'unavailable' });
             if (member.state === 'suspended')
                 return Object.freeze({ member, availability: 'suspended', presence: 'unavailable' });
-            const diagnostic = this.diagnostics.get(member.memberId);
-            if (diagnostic !== undefined)
-                return Object.freeze({ member, availability: 'unavailable', presence: 'unavailable', diagnostic });
+            const failures = this.memberFailures.get(member.memberId);
+            if (failures?.activation !== undefined)
+                return Object.freeze({ member, availability: 'unavailable', presence: 'unavailable', diagnostic: failures.activation });
             const handle = this.handles.get(member.memberId);
             if (handle === undefined)
                 return Object.freeze({ member, availability: 'unavailable', presence: 'unavailable' });
-            const runtimeError = this.runtimeErrors.get(handle.agent.id);
+            if (this.ctx.agentPresets.composedPreset(handle.agent.ctx) === undefined) {
+                return Object.freeze({ member, availability: 'active', presence: 'error', diagnostic: ORPHANED_MEMBER_DIAGNOSTIC });
+            }
+            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' });
         }
+        setMemberFailure(memberId, slot, message) {
+            const failures = this.memberFailures.get(memberId) ?? {};
+            failures[slot] = message;
+            this.memberFailures.set(memberId, failures);
+        }
+        clearMemberFailure(memberId, slot) {
+            const failures = this.memberFailures.get(memberId);
+            if (failures === undefined || failures[slot] === undefined)
+                return false;
+            if (Object.keys(failures).length === 1)
+                this.memberFailures.delete(memberId);
+            else
+                delete failures[slot];
+            return true;
+        }
         requireWorkspace(workspaceId) {
             const workspace = this.ctx.workspaceRegistry.get(workspaceId);
             if (workspace === undefined)
@@ -961,6 +1005,13 @@ let AgentTeam = (() => {
                 if (handle !== undefined)
                     this.notifyMember(handle.agent);
             }
+            const compactionMembers = acceptedTaskCompactionMembers(operation);
+            if (compactionMembers !== undefined)
+                this.autoCompaction.schedule(compactionMembers);
+        }
+        emitAutoCompactionChanged(memberId) {
+            const workspaceId = this.ledger?.getMember(memberId)?.workspaceId;
+            this.emitChanged(workspaceId === undefined ? undefined : [{ kind: 'workspace', workspaceId }]);
         }
         /** Wake from durable unread state with bounded facts for direct and state-changing work. */
         notifyMember(agent) {
@@ -977,12 +1028,19 @@ let AgentTeam = (() => {
             ]));
             if (this.notifiedInbox.get(member.memberId) === signature)
                 return;
-            const existingHint = [...agent.inbox.nextStep, ...agent.inbox.nextTurn].find(message => message.source.kind === 'plugin' && message.source.plugin === '@wowyuarm/dsh-agent-team');
-            if (existingHint !== undefined)
-                agent.inbox.remove(existingHint.id);
+            const pending = [...agent.inbox.nextStep, ...agent.inbox.nextTurn];
+            // steerResume already combines the recovery instruction and these durable
+            // facts. Its synchronous running transition must not replace that notice.
+            if (pending.some(message => this.isRecoveryNotice(message))) {
+                this.notifiedInbox.set(member.memberId, signature);
+                return;
+            }
+            const existingInboxHint = pending.find(message => this.isInboxNotice(message));
+            if (existingInboxHint !== undefined)
+                agent.inbox.remove(existingInboxHint.id);
             const hint = createUserMessage({
                 content: [{ type: 'text', text: this.notificationText(notifications, member.memberId) }],
-                source: { kind: 'plugin', plugin: '@wowyuarm/dsh-agent-team', form: 'notice', summary: 'Team Inbox has unread work.' },
+                source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: INBOX_NOTICE_SUMMARY },
             });
             this.notifiedInbox.set(member.memberId, signature);
             try {
@@ -993,6 +1051,16 @@ let AgentTeam = (() => {
                 throw error;
             }
         }
+        isInboxNotice(message) {
+            const source = message.source;
+            return source.kind === 'plugin' && source.plugin === AGENT_TEAM_PLUGIN_ID
+                && source.form === 'notice' && source.summary === INBOX_NOTICE_SUMMARY;
+        }
+        isRecoveryNotice(message) {
+            const source = message.source;
+            return source.kind === 'plugin' && source.plugin === AGENT_TEAM_PLUGIN_ID
+                && source.form === 'notice' && source.summary === RECOVERY_NOTICE_SUMMARY;
+        }
         notificationText(notifications, readerId) {
             const maxCharacters = 32 * 1024;
             const sections = ['Team Inbox has unread work.'];
@@ -1061,6 +1129,22 @@ let AgentTeam = (() => {
                 ? ` Released Claims: ${activity.releasedClaimRefs.join(', ')}.` : '';
             return `Team Task update\n${actor} ${activity.kind} Task ${activity.taskRef}.${released}`;
         }
+        /** Dispose one live Member Session and drop its per-Member runtime state. */
+        async disposeMemberSession(memberId, member) {
+            this.clearMemberRecoveryState(member);
+            const handle = this.handles.get(memberId);
+            if (handle !== undefined) {
+                await handle.dispose();
+                this.handles.delete(memberId);
+            }
+            this.modelSelections.delete(memberId);
+            this.clearMemberFailure(memberId, 'activation');
+        }
+        clearMemberRecoveryState(member) {
+            this.recovery.stopTracking(member.memberId);
+            this.clearMemberFailure(member.memberId, 'runtime');
+            this.clearMemberNotificationState(member.memberId);
+        }
         clearMemberNotificationState(memberId) {
             this.notifiedInbox.delete(memberId);
         }