@wowyuarm/dsh-agent-team 0.1.1 → 0.1.3

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

@@ -44,20 +44,26 @@ 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';
 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 { 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;
@@ -83,13 +89,13 @@ export const AGENT_TEAM_TOOL_NAMES = Object.freeze([
 let AgentTeam = (() => {
     let _classSuper = TypertRemoteService;
     let _instanceExtraInitializers = [];
+    let _resolveTaskRefs_decorators;
     let _membersForClient_decorators;
     let _changes_decorators;
     let _createChannel_decorators;
     let _updateChannel_decorators;
     let _addMember_decorators;
     let _recoverMember_decorators;
-    let _restartMember_decorators;
     let _updateMember_decorators;
     let _changeTask_decorators;
     let _joinChannel_decorators;
@@ -107,13 +113,13 @@ let AgentTeam = (() => {
     return class AgentTeam extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _resolveTaskRefs_decorators = [Remote('resolveTaskRefs')];
             _membersForClient_decorators = [Remote('members')];
             _changes_decorators = [Remote('changes')];
             _createChannel_decorators = [Remote('createChannel')];
             _updateChannel_decorators = [Remote('updateChannel')];
             _addMember_decorators = [Remote('addMember')];
             _recoverMember_decorators = [Remote('recoverMember')];
-            _restartMember_decorators = [Remote('restartMember')];
             _updateMember_decorators = [Remote('updateMember')];
             _changeTask_decorators = [Remote('changeTask')];
             _joinChannel_decorators = [Remote('joinChannel')];
@@ -128,13 +134,13 @@ let AgentTeam = (() => {
             _threadObservations_decorators = [Remote('threadObservations')];
             _threadHistory_decorators = [Remote('threadHistory')];
             _view_decorators = [Remote('view')];
+            __esDecorate(this, null, _resolveTaskRefs_decorators, { kind: "method", name: "resolveTaskRefs", static: false, private: false, access: { has: obj => "resolveTaskRefs" in obj, get: obj => obj.resolveTaskRefs }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _membersForClient_decorators, { kind: "method", name: "membersForClient", static: false, private: false, access: { has: obj => "membersForClient" in obj, get: obj => obj.membersForClient }, metadata: _metadata }, null, _instanceExtraInitializers);
             __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, _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, _restartMember_decorators, { kind: "method", name: "restartMember", static: false, private: false, access: { has: obj => "restartMember" in obj, get: obj => obj.restartMember }, 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, _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, _joinChannel_decorators, { kind: "method", name: "joinChannel", static: false, private: false, access: { has: obj => "joinChannel" in obj, get: obj => obj.joinChannel }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -163,19 +169,28 @@ let AgentTeam = (() => {
         domain = __runInitializers(this, _instanceExtraInitializers);
         ledger;
         handles = new Map();
-        diagnostics = new Map();
-        runtimeErrors = new Map();
+        /** Live selection refs let model edits take effect without disposing the Session. */
+        modelSelections = 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();
@@ -184,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]() {
@@ -192,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 }]);
             });
@@ -206,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);
                 }
             });
@@ -221,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;
@@ -228,6 +259,7 @@ let AgentTeam = (() => {
                 await this.lifecycleTail;
                 await Promise.all([...this.handles.values()].map(handle => handle.dispose()));
                 this.handles.clear();
+                this.modelSelections.clear();
                 this.runningAgents.clear();
                 await domain.close();
             }, 'agentTeam.dispose');
@@ -260,6 +292,18 @@ let AgentTeam = (() => {
         members() {
             return this.requireLedger().listMembers().map(member => this.memberStatus(member));
         }
+        /** Read-only navigation lookup for branded Task refs found in message bodies. */
+        resolveTaskRefs(request) {
+            this.requireWorkspace(request.workspaceId);
+            const seen = new Set();
+            const taskRefs = request.taskRefs.filter(taskRef => {
+                if (seen.has(taskRef))
+                    return false;
+                seen.add(taskRef);
+                return true;
+            });
+            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);
@@ -366,13 +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.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) });
             });
         }
@@ -397,54 +435,19 @@ 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) });
         }
-        /**
-         * Restart one enabled Member's live session in place: dispose the handle and
-         * reactivate on the same session id, so the transcript, private memory, and
-         * every ledger fact survive while tools and prompt templates are re-minted
-         * from the running plugin. The audit operation changes no projection state.
-         */
-        async restartMember(request) {
-            return this.enqueueLifecycle(async () => {
-                this.requireAccepting();
-                this.requireWorkspace(request.workspaceId);
-                const stored = this.requireLedger().getMember(request.memberId);
-                if (stored === undefined || stored.workspaceId !== request.workspaceId)
-                    throw new Error(`unknown Member '${request.memberId}' in workspace '${request.workspaceId}'`);
-                if (stored.state !== 'enabled')
-                    throw new Error(`Agent Member '${stored.handle}' is ${stored.state}; only enabled Members can be restarted`);
-                const active = this.handles.get(request.memberId);
-                if (active === undefined)
-                    throw new Error(`Agent Member '${stored.handle}' has no active session to restart`);
-                if (this.runningAgents.has(active.agent.id))
-                    throw new Error(`Agent Member '${stored.handle}' is still running; wait for the current turn to end before restarting`);
-                const result = await this.requireLedger().restartMember({ ...request, actor: agentTeamHumanActor() });
-                if (result.committed)
-                    this.emitCommitted(result.value.receipt);
-                // 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);
-                this.runtimeErrors.delete(active.agent.id);
-                this.notifiedInbox.delete(request.memberId);
-                await active.dispose();
-                this.handles.delete(request.memberId);
-                this.diagnostics.delete(request.memberId);
-                await this.activateMember(stored);
-                const reactivated = this.handles.get(request.memberId);
-                if (reactivated === undefined) {
-                    // Reactivation failed; the activation diagnostic carries the reason and
-                    // the audit record stays honest about the attempt.
-                    throw new Error(`Agent Member '${stored.handle}' failed to reactivate: ${this.diagnostics.get(request.memberId) ?? 'unknown error'}`);
-                }
-                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(stored) });
-            });
-        }
         /** Ledger handle for log lines; falls back to the raw id when unknown. */
         memberLabel(memberId) {
             return this.ledger?.getMember(memberId)?.handle ?? memberId;
@@ -463,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
@@ -494,27 +482,31 @@ let AgentTeam = (() => {
             if (handle === undefined)
                 throw new Error(`member '${member.handle}' has no active session`);
             const notifications = this.requireLedger().notificationFacts(member.memberId, { workspaceId: member.workspaceId });
-            const body = notifications.length === 0 ? text : `${text}\n\n${this.notificationText(notifications)}`;
+            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 model change restarts an
-         * active Member: single-Session Members read their selection only at
-         * activation, so the quiescing dispose plus reactivation applies the new
-         * provider/model immediately instead of at the next Host restart.
+         * Human edit of one Member's mutable facts. A live model selection is
+         * updated in place: disposing an Agent emits session/disposed, which makes
+         * the Web Client permanently mark the same Session id unavailable even when
+         * Team immediately recreates it.
          */
         async updateMember(request) {
             return this.enqueueLifecycle(async () => {
@@ -526,9 +518,10 @@ let AgentTeam = (() => {
                 const stored = result.value.member;
                 const active = this.handles.get(request.memberId);
                 if (active !== undefined && !isDeepStrictEqual(previous?.model ?? undefined, stored.model ?? undefined)) {
-                    await active.dispose();
-                    this.handles.delete(request.memberId);
-                    await this.activateMember(stored);
+                    const selection = this.modelSelections.get(request.memberId);
+                    if (selection === undefined)
+                        throw new Error(`Agent Member '${stored.handle}' has no live model selection`);
+                    selection.current = stored.model ?? this.ctx.agentDefaultModel.currentSelection();
                 }
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(stored) });
             });
@@ -539,13 +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.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;
             });
@@ -560,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
@@ -628,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. */
@@ -653,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;
@@ -680,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;
@@ -704,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);
@@ -747,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;
@@ -765,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);
@@ -804,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)
@@ -844,9 +818,16 @@ let AgentTeam = (() => {
                 await this.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
+                // through the public Agent model-selection seam so reasoning effort is
+                // applied to the next request and not lost during activation.
+                const selection = member.model ?? this.ctx.agentDefaultModel.currentSelection();
+                const agentOptions = { provider: selection.provider, model: selection.model };
+                const selected = { current: selection, assembled: undefined };
                 const setup = async (agentCtx) => {
                     await this.ctx.agentPresets.mount(agentCtx, member.presetId);
                     this.validateMemberPreset(agentCtx);
+                    installModelSelection(agentCtx, selected);
                     return {
                         commit: () => {
                             const agent = agentCtx.agent;
@@ -857,10 +838,6 @@ let AgentTeam = (() => {
                         },
                     };
                 };
-                // A Member-pinned selection wins; otherwise the Host default applies at
-                // every activation, so an override survives restarts and a cleared one
-                // re-reads the live default.
-                const agentOptions = member.model ?? this.ctx.agentDefaultModel.currentSelection();
                 created = persisted
                     ? await this.ctx.agents.resume({ resumeSessionId: member.sessionId, agentOptions, setup })
                     : await this.ctx.agents.create({
@@ -871,19 +848,51 @@ let AgentTeam = (() => {
                     });
                 await workspace.attachSession(member.sessionId);
                 this.handles.set(member.memberId, created);
-                this.diagnostics.delete(member.memberId);
+                this.modelSelections.set(member.memberId, selected);
+                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.diagnostics.set(member.memberId, error instanceof Error ? error.message : String(error));
+                this.modelSelections.delete(member.memberId);
+                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
@@ -938,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)
@@ -978,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) {
@@ -994,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) }],
-                source: { kind: 'plugin', plugin: '@wowyuarm/dsh-agent-team', form: 'notice', summary: 'Team Inbox has unread work.' },
+                content: [{ type: 'text', text: this.notificationText(notifications, member.memberId) }],
+                source: { kind: 'plugin', plugin: AGENT_TEAM_PLUGIN_ID, form: 'notice', summary: INBOX_NOTICE_SUMMARY },
             });
             this.notifiedInbox.set(member.memberId, signature);
             try {
@@ -1010,7 +1051,17 @@ let AgentTeam = (() => {
                 throw error;
             }
         }
-        notificationText(notifications) {
+        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.'];
             let characterCount = sections[0].length;
@@ -1036,19 +1087,19 @@ let AgentTeam = (() => {
                             ? 'human' : this.requireLedger().getMember(fact.message.sender)?.handle ?? fact.message.sender;
                         const detail = ['Direct Team mention', `From: ${sender}`, `Channel: ${item.channelRef}`,
                             `Task: ${item.task.taskRef}`, `Thread: ${item.thread.threadRef}`, `Message ref: ${fact.message.messageRef}`,
-                            `Revision: ${item.thread.revision}`, `Message: ${this.boundedNotificationBody(fact.message.body)}`].join('\n');
+                            `Message: ${this.boundedNotificationBody(fact.message.body)}`].join('\n');
                         if (append(detail))
                             detailedFactCount += 1;
                     }
                     else if (fact.kind === 'activity') {
-                        const detail = `${this.activityNotification(fact.activity)}\nThread: ${item.thread.threadRef}\nRevision: ${item.thread.revision}`;
+                        const detail = `${this.activityNotification(fact.activity, readerId)}\nThread: ${item.thread.threadRef}`;
                         if (append(detail))
                             detailedFactCount += 1;
                     }
                 }
                 const ordinaryCount = facts.filter(entry => entry.fact.kind === 'message' && !entry.direct).length;
                 if (ordinaryCount > 0)
-                    append(`Task ${item.task.taskRef}: ${ordinaryCount} unread update${ordinaryCount === 1 ? '' : 's'}; revision ${item.thread.revision}.`);
+                    append(`Task ${item.task.taskRef}: ${ordinaryCount} unread update${ordinaryCount === 1 ? '' : 's'}.`);
             }
             if (omitted)
                 sections.push('More unread work remains in team_inbox; the automatic context is bounded.');
@@ -1059,9 +1110,15 @@ let AgentTeam = (() => {
             const limit = 8 * 1024;
             return body.length <= limit ? body : `${body.slice(0, limit)}\n[Message body truncated; use team_thread read for the full Message.]`;
         }
-        activityNotification(activity) {
+        activityNotification(activity, readerId) {
             const actor = activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID
                 ? 'human' : this.requireLedger().getMember(activity.actor)?.handle ?? activity.actor;
+            // Early acceptance completes the reader's own open Claim inside the accept
+            // operation: say so plainly, or the owner keeps working on a done Task.
+            if (activity.kind === 'accept' && activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID && readerId !== undefined
+                && activity.completedClaimRefs?.some(claimRef => this.requireLedger().getClaim(claimRef)?.owner === readerId)) {
+                return `Team Task update\n${actor} accepted Task ${activity.taskRef} and your open Claim was completed with it. No further work is needed.`;
+            }
             if (activity.kind === 'claim' || activity.kind === 'done' || activity.kind === 'release') {
                 return `Team Task update\n${actor} ${activity.kind} Claim ${activity.claimRef} on Task ${activity.taskRef}.`;
             }
@@ -1072,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);
         }