@wowyuarm/dsh-agent-team 0.1.0 → 0.1.2

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

@@ -44,13 +44,16 @@ 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 { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.js";
+import { classifyRecoverableError, RecoveryCoordinator, RECOVERY_MAX_ATTEMPTS } 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";
@@ -81,16 +84,20 @@ 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 _updateMember_decorators;
     let _changeTask_decorators;
     let _joinChannel_decorators;
     let _removeChannelMember_decorators;
     let _sendMessage_decorators;
+    let _putAttachment_decorators;
+    let _getAttachment_decorators;
     let _reply_decorators;
     let _changeAttention_decorators;
     let _inbox_decorators;
@@ -101,16 +108,20 @@ 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')];
             _updateMember_decorators = [Remote('updateMember')];
             _changeTask_decorators = [Remote('changeTask')];
             _joinChannel_decorators = [Remote('joinChannel')];
             _removeChannelMember_decorators = [Remote('removeChannelMember')];
             _sendMessage_decorators = [Remote('sendMessage')];
+            _putAttachment_decorators = [Remote('putAttachment')];
+            _getAttachment_decorators = [Remote('getAttachment')];
             _reply_decorators = [Remote('reply')];
             _changeAttention_decorators = [Remote('changeAttention')];
             _inbox_decorators = [Remote('inbox')];
@@ -118,16 +129,20 @@ 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, _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);
             __esDecorate(this, null, _removeChannelMember_decorators, { kind: "method", name: "removeChannelMember", static: false, private: false, access: { has: obj => "removeChannelMember" in obj, get: obj => obj.removeChannelMember }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _sendMessage_decorators, { kind: "method", name: "sendMessage", static: false, private: false, access: { has: obj => "sendMessage" in obj, get: obj => obj.sendMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _putAttachment_decorators, { kind: "method", name: "putAttachment", static: false, private: false, access: { has: obj => "putAttachment" in obj, get: obj => obj.putAttachment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getAttachment_decorators, { kind: "method", name: "getAttachment", static: false, private: false, access: { has: obj => "getAttachment" in obj, get: obj => obj.getAttachment }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _reply_decorators, { kind: "method", name: "reply", static: false, private: false, access: { has: obj => "reply" in obj, get: obj => obj.reply }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _changeAttention_decorators, { kind: "method", name: "changeAttention", static: false, private: false, access: { has: obj => "changeAttention" in obj, get: obj => obj.changeAttention }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _inbox_decorators, { kind: "method", name: "inbox", static: false, private: false, access: { has: obj => "inbox" in obj, get: obj => obj.inbox }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -149,9 +164,23 @@ let AgentTeam = (() => {
         domain = __runInitializers(this, _instanceExtraInitializers);
         ledger;
         handles = new Map();
+        /** Live selection refs let model edits take effect without disposing the Session. */
+        modelSelections = new Map();
         diagnostics = new Map();
         runtimeErrors = new Map();
+        /** 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);
+            },
+            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`);
+            },
+        });
         lifecycleTail = Promise.resolve();
         accepting = true;
         changeVersion = 0;
@@ -165,11 +194,20 @@ let AgentTeam = (() => {
                 const member = this.memberForAgent(agent);
                 if (member === undefined)
                     return;
-                this.runtimeErrors.set(agent.id, error instanceof Error ? error.message : String(error));
+                const message = error instanceof Error ? error.message : String(error);
+                this.runtimeErrors.set(agent.id, 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.recovery.onError(member.memberId, message);
                 this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
             });
             this.ctx.on('agent/status', ({ agent, status }) => {
                 const member = this.memberForAgent(agent);
+                if (status === 'running')
+                    this.runningAgents.add(agent.id);
+                else
+                    this.runningAgents.delete(agent.id);
                 if (status === 'running' && member !== undefined) {
                     const recovered = this.runtimeErrors.delete(agent.id);
                     if (recovered)
@@ -177,14 +215,24 @@ let AgentTeam = (() => {
                     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)) {
+                    this.recovery.onCleanTurnEnd(member.memberId);
+                }
             });
             const domain = await this.ctx.storageDomain.open(agentTeamDomainSpec);
             this.ctx.effect(() => async () => {
                 this.accepting = false;
+                this.recovery.dispose();
+                if (this.attachmentGcTimer !== undefined)
+                    clearInterval(this.attachmentGcTimer);
+                this.attachmentGcTimer = undefined;
                 this.emitChanged();
                 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');
             this.domain = domain;
@@ -193,6 +241,7 @@ let AgentTeam = (() => {
             const initialization = await ledger.initialize();
             if (initialization.committed)
                 this.emitCommitted(initialization.value);
+            this.startAttachmentGc(ledger);
             // One metadata listing serves every Member restore; per-member list calls
             // would repeat the same I/O linearly during startup.
             const persistedSessions = new Set((await this.ctx.sessionPersistence.list()).map(header => header.id));
@@ -216,6 +265,18 @@ let AgentTeam = (() => {
             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);
+            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)) });
+        }
         membersForClient(request) {
             this.requireWorkspace(request.workspaceId);
             return this.members()
@@ -293,6 +354,7 @@ let AgentTeam = (() => {
         async addMember(request) {
             return this.enqueueLifecycle(async () => {
                 const workspace = this.requireWorkspace(request.workspaceId);
+                await this.assertModelRoute(request.model);
                 const memberId = `member:${randomUUID()}`;
                 const member = Object.freeze({
                     memberId,
@@ -325,6 +387,7 @@ let AgentTeam = (() => {
                     await handle.dispose();
                     this.handles.delete(request.memberId);
                 }
+                this.modelSelections.delete(request.memberId);
                 this.diagnostics.delete(request.memberId);
                 this.clearMemberNotificationState(request.memberId);
                 return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
@@ -342,13 +405,96 @@ let AgentTeam = (() => {
             });
         }
         /**
-         * 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.
+         * Operator nudge for an error-stopped Member: steer a continuation prompt
+         * into its live session. Runtime-only — no ledger operation, no suspend.
+         * Taking over manually also cancels any pending automatic recovery episode.
+         */
+        async recoverMember(request) {
+            this.requireAccepting();
+            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 ?? '');
+            this.ctx.logger.info(`agent-team: operator asked member '${member.handle}' to resume`);
+            this.steerResume(member, this.resumeText(kind ?? 'unspecified failure', { operatorRequested: true }));
+            return Object.freeze({ status: this.memberStatus(member) });
+        }
+        /** Ledger handle for log lines; falls back to the raw id when unknown. */
+        memberLabel(memberId) {
+            return this.ledger?.getMember(memberId)?.handle ?? memberId;
+        }
+        /**
+         * Cache GC: uploads referenced by a Message survive 72h from upload so
+         * Member agents keep a consumption window; orphans (never sent) go after
+         * 24h. Runs once at startup and then daily — in-process only, because the
+         * cache is transient by design and rebuilds nothing across restarts.
+         */
+        startAttachmentGc(ledger) {
+            const sweep = async () => {
+                await sweepAttachmentCache(attachmentsRoot(), ledger.referencedAttachmentIds(), Date.now());
+            };
+            void sweep();
+            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);
+        }
+        /**
+         * 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;
+        }
+        /**
+         * Steer one continuation message into a Member's live session. Throws when
+         * no handle exists so the coordinator stops tracking; appends the inbox
+         * snapshot whenever there is anything new to read.
+         */
+        steerResume(member, text) {
+            const handle = this.handles.get(member.memberId);
+            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, 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.' },
+            });
+            handle.agent.steer(hint);
+        }
+        /** Automatic-recovery injection; throwing tells the coordinator the target is gone. */
+        injectRecovery(memberId, attempt, kind) {
+            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 }));
+        }
+        /**
+         * 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 () => {
+                await this.assertModelRoute(request.model);
                 const previous = this.requireLedger().getMember(request.memberId);
                 const result = await this.requireLedger().updateMember({ ...request, actor: agentTeamHumanActor() });
                 if (result.committed)
@@ -356,9 +502,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) });
             });
@@ -374,6 +521,7 @@ let AgentTeam = (() => {
                     await handle.dispose();
                     this.handles.delete(request.memberId);
                 }
+                this.modelSelections.delete(request.memberId);
                 this.diagnostics.delete(request.memberId);
                 this.clearMemberNotificationState(request.memberId);
                 await this.cleanupRemovedMember(result.value.member);
@@ -413,15 +561,84 @@ let AgentTeam = (() => {
         async sendMessage(request) {
             this.requireAccepting();
             this.requireWorkspace(request.workspaceId);
-            const result = await this.requireLedger().sendMessage({ ...request, actor: agentTeamHumanActor() });
+            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;
         }
+        /**
+         * Resolve uploaded ids and agent-supplied absolute paths into one attachment
+         * metadata list. Paths are all validated before anything is copied, so one
+         * rejection leaves the cache untouched and the message uncommitted.
+         */
+        async resolveMessageAttachments(request) {
+            const fromPaths = [];
+            if (request.attachmentPaths !== undefined && request.attachmentPaths.length > 0) {
+                for (const absolutePath of request.attachmentPaths)
+                    await validatePathAttachment(absolutePath);
+                for (const absolutePath of request.attachmentPaths)
+                    fromPaths.push(Object.freeze(await copyPathAttachment(attachmentsRoot(), absolutePath)));
+            }
+            return [...fromPaths, ...await this.prepareAttachments(request.attachments)];
+        }
+        /** Verify requested attachment ids against the cache. */
+        async prepareAttachments(requested) {
+            if (requested === undefined || requested.length === 0)
+                return [];
+            const metadata = [];
+            for (const attachmentId of requested) {
+                const stored = await readAttachment(attachmentsRoot(), attachmentId);
+                if (stored === undefined)
+                    throw new Error(`attachment '${attachmentId}' is not in the upload cache`);
+                metadata.push(Object.freeze({ attachmentId, name: stored.name, byteSize: stored.byteSize, mediaType: stored.mediaType }));
+            }
+            return metadata;
+        }
+        /**
+         * Derive the stored body: one machine-facing `[attachment] <absolute path>`
+         * line per attachment appended to the member-facing text.
+         */
+        appendAttachmentLines(body, metadata) {
+            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)}`);
+            return `${trimmed}\n${lines.join('\n')}`;
+        }
+        /** Upload one composer attachment into the cache; bytes are immutable once written. */
+        async putAttachment(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const bytes = Buffer.from(request.bytesBase64, 'base64');
+            if (bytes.byteLength === 0)
+                throw new Error('attachment must not be empty');
+            if (bytes.byteLength > ATTACHMENT_MAX_BYTES)
+                throw new Error(`attachment exceeds the ${ATTACHMENT_MAX_BYTES} byte limit`);
+            const mediaType = sanitizeMediaType(request.mediaType);
+            const attachmentId = newAttachmentId();
+            return Object.freeze(await writeAttachment(attachmentsRoot(), attachmentId, request.name, mediaType, bytes));
+        }
+        /** Read one cached attachment back for client display; gone entries throw and the UI degrades to a chip. */
+        async getAttachment(request) {
+            const stored = await readAttachment(attachmentsRoot(), request.attachmentId);
+            if (stored === undefined)
+                throw new Error(`attachment '${request.attachmentId}' is no longer cached`);
+            return Object.freeze({ name: stored.name, mediaType: stored.mediaType, byteSize: stored.byteSize, bytesBase64: stored.bytes.toString('base64') });
+        }
         /** Human existing-Thread reply; unread and revision conflicts are business outcomes. */
         async reply(request) {
             this.requireAccepting();
             this.requireWorkspace(request.workspaceId);
-            const result = await this.requireLedger().reply({ ...request, actor: agentTeamHumanActor() });
+            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;
         }
@@ -468,7 +685,12 @@ let AgentTeam = (() => {
             this.requireAccepting();
             const actor = this.memberActor(agent);
             this.requireAgentWorkspace(actor, request.workspaceId);
-            const result = await this.requireLedger().sendMessage({ ...request, actor });
+            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;
         }
@@ -477,7 +699,12 @@ let AgentTeam = (() => {
             this.requireAccepting();
             const actor = this.memberActor(agent);
             this.requireAgentWorkspace(actor, request.workspaceId);
-            const result = await this.requireLedger().reply({ ...request, actor });
+            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;
         }
@@ -565,6 +792,26 @@ let AgentTeam = (() => {
             if (this.requireLedger().getMember(actor.memberId)?.workspaceId !== workspaceId)
                 throw new Error('Member cannot mutate another Workspace');
         }
+        /**
+         * Validate a pinned model route's reasoning effort against the adapter's own
+         * metadata when the LLM service is reachable; unknown routes defer to the
+         * LLM layer's runtime check at call time.
+         */
+        async assertModelRoute(model) {
+            if (model === undefined || model.reasoningEffort === undefined)
+                return;
+            try {
+                const resolved = await this.ctx.llm.resolveModelInfo(model.provider, model.model);
+                const efforts = resolved.reasoning?.efforts ?? [];
+                if (efforts.length > 0 && !efforts.some(effort => effort.id === model.reasoningEffort)) {
+                    throw new Error(`reasoning effort '${model.reasoningEffort}' is not supported by ${model.provider}/${model.model}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('is not supported by'))
+                    throw error;
+            }
+        }
         async activateMember(member, knownWorkspacePath, knownSessions) {
             if (this.handles.has(member.memberId))
                 return;
@@ -575,9 +822,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;
@@ -588,10 +842,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({
@@ -602,12 +852,14 @@ 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.nameMemberSession(member, created.agent);
                 this.notifyMember(created.agent);
             }
             catch (error) {
                 await created?.dispose();
+                this.modelSelections.delete(member.memberId);
                 this.diagnostics.set(member.memberId, error instanceof Error ? error.message : String(error));
             }
             finally {
@@ -729,7 +981,7 @@ let AgentTeam = (() => {
             if (existingHint !== undefined)
                 agent.inbox.remove(existingHint.id);
             const hint = createUserMessage({
-                content: [{ type: 'text', text: this.notificationText(notifications) }],
+                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.' },
             });
             this.notifiedInbox.set(member.memberId, signature);
@@ -741,7 +993,7 @@ let AgentTeam = (() => {
                 throw error;
             }
         }
-        notificationText(notifications) {
+        notificationText(notifications, readerId) {
             const maxCharacters = 32 * 1024;
             const sections = ['Team Inbox has unread work.'];
             let characterCount = sections[0].length;
@@ -767,19 +1019,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.');
@@ -790,9 +1042,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}.`;
             }