@wowyuarm/dsh-agent-team 0.1.0

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

@@ -0,0 +1,841 @@
+/**
+ * Durable Agent Team Host capability.
+ *
+ * The Host owns the append-only collaboration ledger and all Member lifecycle
+ * effects. Session history and browser state are projections, never Team facts.
+ * @module @wowyuarm/dsh-agent-team
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { Service } from '@deepseek-ai/cordis';
+import { 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 { AGENT_TEAM_HUMAN_MEMBER_ID, AgentTeamLedger, agentTeamHumanActor } from "./ledger.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');
+function sameChangeScope(left, right) {
+    if (left.kind === 'workspace' && right.kind === 'workspace')
+        return left.workspaceId === right.workspaceId;
+    if (left.kind === 'channel' && right.kind === 'channel')
+        return left.channelRef === right.channelRef;
+    if (left.kind === 'thread' && right.kind === 'thread')
+        return left.threadRef === right.threadRef;
+    return false;
+}
+/** Mark the preset's `team_message` definition as an Agent Team consumer. */
+export function markAgentTeamPreset(definition) {
+    Object.defineProperty(definition, AGENT_TEAM_PRESET_MARKER, { value: true });
+    return definition;
+}
+/** Model-facing capabilities every Team-enabled preset must publish. */
+export const AGENT_TEAM_TOOL_NAMES = Object.freeze([
+    'team_inbox',
+    'team_thread',
+    'team_message',
+    'team_claim',
+    'team_view',
+]);
+let AgentTeam = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _membersForClient_decorators;
+    let _changes_decorators;
+    let _createChannel_decorators;
+    let _updateChannel_decorators;
+    let _addMember_decorators;
+    let _updateMember_decorators;
+    let _changeTask_decorators;
+    let _joinChannel_decorators;
+    let _removeChannelMember_decorators;
+    let _sendMessage_decorators;
+    let _reply_decorators;
+    let _changeAttention_decorators;
+    let _inbox_decorators;
+    let _readThread_decorators;
+    let _threadObservations_decorators;
+    let _threadHistory_decorators;
+    let _view_decorators;
+    return class AgentTeam extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _membersForClient_decorators = [Remote('members')];
+            _changes_decorators = [Remote('changes')];
+            _createChannel_decorators = [Remote('createChannel')];
+            _updateChannel_decorators = [Remote('updateChannel')];
+            _addMember_decorators = [Remote('addMember')];
+            _updateMember_decorators = [Remote('updateMember')];
+            _changeTask_decorators = [Remote('changeTask')];
+            _joinChannel_decorators = [Remote('joinChannel')];
+            _removeChannelMember_decorators = [Remote('removeChannelMember')];
+            _sendMessage_decorators = [Remote('sendMessage')];
+            _reply_decorators = [Remote('reply')];
+            _changeAttention_decorators = [Remote('changeAttention')];
+            _inbox_decorators = [Remote('inbox')];
+            _readThread_decorators = [Remote('readThread')];
+            _threadObservations_decorators = [Remote('threadObservations')];
+            _threadHistory_decorators = [Remote('threadHistory')];
+            _view_decorators = [Remote('view')];
+            __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, _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, _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);
+            __esDecorate(this, null, _readThread_decorators, { kind: "method", name: "readThread", static: false, private: false, access: { has: obj => "readThread" in obj, get: obj => obj.readThread }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _threadObservations_decorators, { kind: "method", name: "threadObservations", static: false, private: false, access: { has: obj => "threadObservations" in obj, get: obj => obj.threadObservations }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _threadHistory_decorators, { kind: "method", name: "threadHistory", static: false, private: false, access: { has: obj => "threadHistory" in obj, get: obj => obj.threadHistory }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _view_decorators, { kind: "method", name: "view", static: false, private: false, access: { has: obj => "view" in obj, get: obj => obj.view }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = [
+            'storageDomain',
+            'workspaceRegistry',
+            'agents',
+            'agentDefaultModel',
+            'agentPresets',
+            'tools',
+            'sessionPersistence',
+        ];
+        domain = __runInitializers(this, _instanceExtraInitializers);
+        ledger;
+        handles = new Map();
+        diagnostics = new Map();
+        runtimeErrors = new Map();
+        notifiedInbox = new Map();
+        lifecycleTail = Promise.resolve();
+        accepting = true;
+        changeVersion = 0;
+        changeWaiters = new Set();
+        constructor(ctx) {
+            super(ctx, 'agentTeam');
+        }
+        /** Open the durable ledger and restore every enabled Member independently. */
+        async [Service.init]() {
+            this.ctx.on('agent/error', ({ agent, error }) => {
+                const member = this.memberForAgent(agent);
+                if (member === undefined)
+                    return;
+                this.runtimeErrors.set(agent.id, error instanceof Error ? error.message : String(error));
+                this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
+            });
+            this.ctx.on('agent/status', ({ agent, status }) => {
+                const member = this.memberForAgent(agent);
+                if (status === 'running' && member !== undefined) {
+                    const recovered = this.runtimeErrors.delete(agent.id);
+                    if (recovered)
+                        this.notifiedInbox.delete(member.memberId);
+                    this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
+                    this.notifyMember(agent);
+                }
+            });
+            const domain = await this.ctx.storageDomain.open(agentTeamDomainSpec);
+            this.ctx.effect(() => async () => {
+                this.accepting = false;
+                this.emitChanged();
+                await this.lifecycleTail;
+                await Promise.all([...this.handles.values()].map(handle => handle.dispose()));
+                this.handles.clear();
+                await domain.close();
+            }, 'agentTeam.dispose');
+            this.domain = domain;
+            const ledger = new AgentTeamLedger(domain.table('operations'));
+            this.ledger = ledger;
+            const initialization = await ledger.initialize();
+            if (initialization.committed)
+                this.emitCommitted(initialization.value);
+            // 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));
+            for (const member of ledger.listMembers()) {
+                if (member.state === 'enabled')
+                    await this.activateMember(member, undefined, persistedSessions);
+                else if (member.state === 'inactive')
+                    await this.cleanupRemovedMember(member);
+            }
+        }
+        /** Resolve one exact live Agent to its durable Team Member; forks do not inherit identity. */
+        memberForAgent(agent) {
+            for (const [memberId, handle] of this.handles) {
+                if (handle.agent === agent)
+                    return this.requireLedger().getMember(memberId);
+            }
+            return undefined;
+        }
+        /** Return every durable Member with current process availability. */
+        members() {
+            return this.requireLedger().listMembers().map(member => this.memberStatus(member));
+        }
+        /** Return only this Workspace's current Member projection to the Client. */
+        membersForClient(request) {
+            this.requireWorkspace(request.workspaceId);
+            return this.members()
+                .filter(status => status.member.workspaceId === request.workspaceId)
+                .map(({ member: { privateMemoryPath: _privateMemoryPath, ...member }, ...status }) => Object.freeze({ ...status, member: Object.freeze(member) }));
+        }
+        /** Wait for a lightweight projection invalidation without exposing ledger records. */
+        async changes(request, signal) {
+            if (!Number.isInteger(request.afterVersion) || request.afterVersion < 0)
+                throw new Error('afterVersion must be a non-negative integer');
+            const scope = this.validateChangeScope(request.scope);
+            if (this.changeVersion > request.afterVersion || !this.accepting)
+                return Object.freeze({ version: this.changeVersion });
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const waiter = {
+                    scope,
+                    wake: version => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        clearTimeout(timeout);
+                        signal?.removeEventListener('abort', onAbort);
+                        resolve(Object.freeze({ version }));
+                    },
+                };
+                const timeout = setTimeout(() => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    this.changeWaiters.delete(waiter);
+                    resolve(Object.freeze({ version: this.changeVersion }));
+                }, 25_000);
+                const onAbort = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timeout);
+                    this.changeWaiters.delete(waiter);
+                    reject(new Error('changes wait was aborted'));
+                };
+                signal?.addEventListener('abort', onAbort, { once: true });
+                if (signal?.aborted === true) {
+                    onAbort();
+                    return;
+                }
+                this.changeWaiters.add(waiter);
+            });
+        }
+        /** Return durable Team status without issuing a model request or a storage write. */
+        status() {
+            return this.requireLedger().status();
+        }
+        async createChannel(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const ledger = this.requireLedger();
+            if (!ledger.hasCommitted(request.requestId))
+                this.assertChannelMembersAvailable(request.memberIds);
+            const result = await ledger.createChannel({ ...request, actor: agentTeamHumanActor() });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        /** Human rename of one Channel's display facts; identity refs are immutable. */
+        async updateChannel(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const result = await this.requireLedger().updateChannel({ ...request, actor: agentTeamHumanActor() });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        /** Create a durable Member and atomically grant its declared initial Channels. */
+        async addMember(request) {
+            return this.enqueueLifecycle(async () => {
+                const workspace = this.requireWorkspace(request.workspaceId);
+                const memberId = `member:${randomUUID()}`;
+                const member = Object.freeze({
+                    memberId,
+                    sessionId: SessionId(`agent-team-${randomUUID()}`),
+                    workspaceId: request.workspaceId,
+                    handle: request.handle,
+                    description: request.description,
+                    presetId: request.presetId,
+                    ...(request.model === undefined ? {} : { model: Object.freeze({ ...request.model }) }),
+                    privateMemoryPath: dshHomePath('agent-team', 'members', memberId),
+                    state: 'enabled',
+                });
+                const result = await this.requireLedger().addMember({ ...request, actor: agentTeamHumanActor(), member });
+                if (result.committed)
+                    this.emitCommitted(result.value.receipt);
+                const stored = result.value.member;
+                if (!this.handles.has(stored.memberId))
+                    await this.activateMember(stored, workspace.path);
+                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(stored) });
+            });
+        }
+        /** Commit suspended intent, then wait for the owned AgentHandle to become quiescent. */
+        async suspendMember(request) {
+            return this.enqueueLifecycle(async () => {
+                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);
+                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
+            });
+        }
+        /** Commit enabled intent and restore the exact persisted Session. */
+        async resumeMember(request) {
+            return this.enqueueLifecycle(async () => {
+                const result = await this.requireLedger().resumeMember({ ...request, actor: agentTeamHumanActor() });
+                if (result.committed)
+                    this.emitCommitted(result.value.receipt);
+                this.clearMemberNotificationState(result.value.member.memberId);
+                await this.activateMember(result.value.member);
+                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(result.value.member) });
+            });
+        }
+        /**
+         * 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.
+         */
+        async updateMember(request) {
+            return this.enqueueLifecycle(async () => {
+                const previous = this.requireLedger().getMember(request.memberId);
+                const result = await this.requireLedger().updateMember({ ...request, actor: agentTeamHumanActor() });
+                if (result.committed)
+                    this.emitCommitted(result.value.receipt);
+                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);
+                }
+                return Object.freeze({ receipt: result.value.receipt, status: this.memberStatus(stored) });
+            });
+        }
+        /** Irreversibly remove one Member, archive its Session, and delete its private namespace. */
+        async removeMember(request) {
+            return this.enqueueLifecycle(async () => {
+                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.cleanupRemovedMember(result.value.member);
+                return result.value;
+            });
+        }
+        /** Human-only Task resolution. Business fences are returned as typed outcomes. */
+        async changeTask(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const result = await this.requireLedger().changeTask({ ...request, actor: agentTeamHumanActor() });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Human-only Channel membership grant; it never injects historical Thread bodies. */
+        async joinChannel(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const ledger = this.requireLedger();
+            if (!ledger.hasCommitted(request.requestId))
+                this.assertChannelMembersAvailable([request.memberId]);
+            const result = await ledger.joinChannel({ ...request, actor: agentTeamHumanActor() });
+            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() });
+            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 result = await this.requireLedger().sendMessage({ ...request, actor: agentTeamHumanActor() });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** 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() });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Human's personal Attention operation. */
+        async changeAttention(request) {
+            this.requireAccepting();
+            this.requireWorkspace(request.workspaceId);
+            const result = await this.requireLedger().changeAttention({ ...request, actor: agentTeamHumanActor() });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        /** Host-only Human Inbox projection; the Web Client does not consume it. */
+        inbox(request) {
+            this.requireWorkspace(request.workspaceId);
+            return this.requireLedger().inbox(agentTeamHumanActor(), request);
+        }
+        /** 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() });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        /** Human-only durable Attention observations for one Thread. */
+        threadObservations(request) {
+            this.requireWorkspace(request.workspaceId);
+            return this.requireLedger().threadObservations(agentTeamHumanActor(), request);
+        }
+        /** Human's non-mutating bounded Thread history. */
+        threadHistory(request) {
+            this.requireWorkspace(request.workspaceId);
+            return this.requireLedger().threadHistory(agentTeamHumanActor(), request);
+        }
+        /** Return the existing bounded public Workspace discovery projection. */
+        view(request) {
+            this.requireWorkspace(request.workspaceId);
+            return this.requireLedger().view(request);
+        }
+        /** 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 result = await this.requireLedger().sendMessage({ ...request, actor });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Agent-only existing-Thread reply. */
+        async replyForAgent(agent, request) {
+            this.requireAccepting();
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            const result = await this.requireLedger().reply({ ...request, actor });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        /** Agent-only personal Attention change. */
+        async changeAttentionForAgent(agent, request) {
+            this.requireAccepting();
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            const result = await this.requireLedger().changeAttention({ ...request, actor });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        attentionStatusForAgent(agent, request) {
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            return this.requireLedger().attentionStatus(actor, request);
+        }
+        /** Agent-only Claim mutation. */
+        async changeClaimForAgent(agent, request) {
+            this.requireAccepting();
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            const result = await this.requireLedger().changeClaim({ ...request, actor });
+            this.emitCommittedOutcome(result);
+            return result.value;
+        }
+        listClaimsForAgent(agent, request) {
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            return this.requireLedger().listClaims(actor, request);
+        }
+        inboxForAgent(agent, request) {
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            return this.requireLedger().inbox(actor, request);
+        }
+        async readThreadForAgent(agent, request) {
+            this.requireAccepting();
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            const result = await this.requireLedger().readThread({ ...request, actor });
+            if (result.committed)
+                this.emitCommitted(result.value.receipt);
+            return result.value;
+        }
+        threadHistoryForAgent(agent, request) {
+            const actor = this.memberActor(agent);
+            this.requireAgentWorkspace(actor, request.workspaceId);
+            return this.requireLedger().threadHistory(actor, request);
+        }
+        /** Agent-only bounded discovery projection. */
+        viewForAgent(agent, request) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined)
+                throw new Error('Agent is not an active Team Member');
+            if (member.workspaceId !== request.workspaceId)
+                throw new Error('Member cannot view another Workspace');
+            return this.requireLedger().view(request, member.memberId);
+        }
+        /** Validate the durable ledger against an independently replayed projection. */
+        validateLedger() {
+            this.requireLedger().validate();
+        }
+        emitCommittedOutcome(result) {
+            if (result.committed && result.value.kind === 'committed' && result.value.receipt !== undefined)
+                this.emitCommitted(result.value.receipt);
+        }
+        assertChannelMembersAvailable(memberIds) {
+            for (const memberId of memberIds ?? []) {
+                const member = this.requireLedger().getMember(memberId);
+                if (member === undefined)
+                    throw new Error(`unknown Agent Member '${memberId}'`);
+                if (this.memberStatus(member).availability !== 'active')
+                    throw new Error(`Agent Member '${memberId}' is not available for Channel membership`);
+            }
+        }
+        memberActor(agent) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined)
+                throw new Error('Agent is not an active Team Member');
+            return Object.freeze({ kind: 'member', memberId: member.memberId, handle: member.handle });
+        }
+        requireAgentWorkspace(actor, workspaceId) {
+            if (this.requireLedger().getMember(actor.memberId)?.workspaceId !== workspaceId)
+                throw new Error('Member cannot mutate another Workspace');
+        }
+        async activateMember(member, knownWorkspacePath, knownSessions) {
+            if (this.handles.has(member.memberId))
+                return;
+            let created;
+            try {
+                const workspace = this.requireWorkspace(member.workspaceId);
+                const workspacePath = knownWorkspacePath ?? workspace.path;
+                await this.initializePrivateMemory(member.privateMemoryPath);
+                const persisted = knownSessions !== undefined ? knownSessions.has(member.sessionId)
+                    : (await this.ctx.sessionPersistence.list()).some(header => header.id === member.sessionId);
+                const setup = async (agentCtx) => {
+                    await this.ctx.agentPresets.mount(agentCtx, member.presetId);
+                    this.validateMemberPreset(agentCtx);
+                    return {
+                        commit: () => {
+                            const agent = agentCtx.agent;
+                            if (agent === undefined)
+                                throw new Error('agent-team setup has no unpublished Agent');
+                            if (effectiveSandboxMode(agent.session.events) !== 'danger-full-access')
+                                setSandboxMode(agent.session, 'danger-full-access');
+                        },
+                    };
+                };
+                // 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({
+                        sessionId: member.sessionId,
+                        meta: { cwd: workspacePath, agentPreset: member.presetId },
+                        agentOptions,
+                        setup,
+                    });
+                await workspace.attachSession(member.sessionId);
+                this.handles.set(member.memberId, created);
+                this.diagnostics.delete(member.memberId);
+                this.nameMemberSession(member, created.agent);
+                this.notifyMember(created.agent);
+            }
+            catch (error) {
+                await created?.dispose();
+                this.diagnostics.set(member.memberId, error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                // Activation only changes this Workspace's presence projection.
+                this.emitChanged([{ kind: 'workspace', workspaceId: member.workspaceId }]);
+            }
+        }
+        /**
+         * 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
+         * cosmetic default never fails Member activation.
+         */
+        nameMemberSession(member, agent) {
+            const sessionTitle = this.ctx.get('sessionTitle');
+            if (sessionTitle === undefined)
+                return;
+            try {
+                if (sessionTitle.get(agent.session) !== undefined)
+                    return;
+                sessionTitle.rename(agent.session, member.handle);
+            }
+            catch {
+                // The composition may carry no session-title service, or the rename may
+                // race its disposal; the Member works identically without the title.
+            }
+        }
+        validateMemberPreset(agentCtx) {
+            const scope = scopeOf(agentCtx);
+            const teamMessage = this.ctx.tools.get('team_message', scope);
+            if (teamMessage?.[AGENT_TEAM_PRESET_MARKER] !== true) {
+                throw new Error('selected preset is not team-enabled');
+            }
+            const available = new Set(this.ctx.tools.schemas(scope).map(tool => tool.name));
+            const missing = AGENT_TEAM_TOOL_NAMES.filter(name => !available.has(name));
+            if (missing.length > 0)
+                throw new Error(`team-enabled preset is missing tools: ${missing.join(', ')}`);
+        }
+        async initializePrivateMemory(path) {
+            await mkdir(join(path, 'notes'), { recursive: true });
+            try {
+                await writeFile(join(path, 'memory.md'), '# Member memory\n\n## Stable facts\n- Add only verified, durable facts that help future work.\n\n## Notes index\n- Add focused `notes/*.md` entries here when a reusable detail needs on-demand reading.\n', { flag: 'wx' });
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+        }
+        async cleanupRemovedMember(member) {
+            const results = await Promise.allSettled([
+                this.ctx.workspaceRegistry.archiveSession(member.sessionId),
+                rm(member.privateMemoryPath, { recursive: true, force: true }),
+            ]);
+            const failures = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+            if (failures.length > 0)
+                throw new AggregateError(failures, `failed to clean up removed Member '${member.memberId}'`);
+        }
+        memberStatus(member) {
+            if (member.state === 'inactive')
+                return Object.freeze({ member, availability: 'inactive', presence: 'unavailable' });
+            if (member.state === '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 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 (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' });
+        }
+        requireWorkspace(workspaceId) {
+            const workspace = this.ctx.workspaceRegistry.get(workspaceId);
+            if (workspace === undefined)
+                throw new Error(`unknown Workspace '${workspaceId}'`);
+            return workspace;
+        }
+        requireLedger() {
+            if (this.ledger === undefined || this.domain === undefined)
+                throw new Error('agent-team service is not initialized');
+            return this.ledger;
+        }
+        requireAccepting() {
+            if (!this.accepting)
+                throw new Error('agent-team service is shutting down');
+        }
+        emitCommitted(receipt) {
+            this.ctx.emit('agent-team/committed', { receipt });
+            const operation = this.ledger?.getOperation(receipt.operationId);
+            if (operation === undefined) {
+                this.emitChanged();
+                return;
+            }
+            const ledger = this.requireLedger();
+            this.emitChanged(ledger.changeScopesOf(operation));
+            for (const memberId of ledger.affectedMembersOf(operation)) {
+                const handle = this.handles.get(memberId);
+                if (handle !== undefined)
+                    this.notifyMember(handle.agent);
+            }
+        }
+        /** Wake from durable unread state with bounded facts for direct and state-changing work. */
+        notifyMember(agent) {
+            const member = this.memberForAgent(agent);
+            if (member === undefined || member.state !== 'enabled')
+                return;
+            const notifications = this.requireLedger().notificationFacts(member.memberId, { workspaceId: member.workspaceId });
+            if (notifications.length === 0) {
+                this.notifiedInbox.delete(member.memberId);
+                return;
+            }
+            const signature = JSON.stringify(notifications.map(({ item }) => [
+                item.thread.threadRef, item.thread.revision, item.unreadCount, item.directCount, item.newestSequence,
+            ]));
+            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 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.' },
+            });
+            this.notifiedInbox.set(member.memberId, signature);
+            try {
+                agent.steer(hint);
+            }
+            catch (error) {
+                this.clearMemberNotificationState(member.memberId);
+                throw error;
+            }
+        }
+        notificationText(notifications) {
+            const maxCharacters = 32 * 1024;
+            const sections = ['Team Inbox has unread work.'];
+            let characterCount = sections[0].length;
+            let detailedFactCount = 0;
+            let omitted = notifications.length > 8;
+            const append = (section) => {
+                if (characterCount + section.length + 2 > maxCharacters) {
+                    omitted = true;
+                    return false;
+                }
+                sections.push(section);
+                characterCount += section.length + 2;
+                return true;
+            };
+            for (const { item, facts } of notifications.slice(0, 8)) {
+                for (const { fact, direct } of facts) {
+                    if (detailedFactCount >= 20) {
+                        omitted = true;
+                        break;
+                    }
+                    if (direct && fact.kind === 'message') {
+                        const sender = fact.message.sender === AGENT_TEAM_HUMAN_MEMBER_ID
+                            ? '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');
+                        if (append(detail))
+                            detailedFactCount += 1;
+                    }
+                    else if (fact.kind === 'activity') {
+                        const detail = `${this.activityNotification(fact.activity)}\nThread: ${item.thread.threadRef}\nRevision: ${item.thread.revision}`;
+                        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}.`);
+            }
+            if (omitted)
+                sections.push('More unread work remains in team_inbox; the automatic context is bounded.');
+            sections.push('Use team_thread read with the relevant taskRef before acting or replying. Use team_inbox only when you need to triage the remaining Threads.');
+            return sections.join('\n\n');
+        }
+        boundedNotificationBody(body) {
+            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) {
+            const actor = activity.actor === AGENT_TEAM_HUMAN_MEMBER_ID
+                ? 'human' : this.requireLedger().getMember(activity.actor)?.handle ?? activity.actor;
+            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}.`;
+            }
+            if (activity.kind === 'claims_released') {
+                return `Team Task update\n${actor}'s Claims ${activity.claimRefs.join(', ')} were released on Task ${activity.taskRef}.`;
+            }
+            const released = 'releasedClaimRefs' in activity && activity.releasedClaimRefs !== undefined && activity.releasedClaimRefs.length > 0
+                ? ` Released Claims: ${activity.releasedClaimRefs.join(', ')}.` : '';
+            return `Team Task update\n${actor} ${activity.kind} Task ${activity.taskRef}.${released}`;
+        }
+        clearMemberNotificationState(memberId) {
+            this.notifiedInbox.delete(memberId);
+        }
+        /**
+         * Wake waiters for one committed or lifecycle change. Undefined broadcasts
+         * to everyone; an empty scope list invalidates nobody because no shared
+         * projection changed; otherwise global and matching scoped waiters wake.
+         */
+        emitChanged(scopes) {
+            this.changeVersion += 1;
+            for (const waiter of this.changeWaiters) {
+                const waiterScope = waiter.scope;
+                if (scopes !== undefined && (waiterScope === undefined ? scopes.length === 0 : !scopes.some(scope => sameChangeScope(scope, waiterScope))))
+                    continue;
+                this.changeWaiters.delete(waiter);
+                waiter.wake(this.changeVersion);
+            }
+        }
+        validateChangeScope(scope) {
+            if (scope === undefined)
+                return undefined;
+            const ref = scope.kind === 'workspace' ? scope.workspaceId : scope.kind === 'channel' ? scope.channelRef : scope.threadRef;
+            if (typeof ref !== 'string' || ref.length === 0)
+                throw new Error(`change scope of kind '${scope.kind}' requires a non-empty ref`);
+            return scope;
+        }
+        enqueueLifecycle(operation) {
+            this.requireAccepting();
+            const result = this.lifecycleTail.then(operation);
+            this.lifecycleTail = result.then(() => { }, () => { });
+            return result;
+        }
+    };
+})();
+/** Host owner of the single Agent Team in one dshHome. */
+export default AgentTeam;