@wowyuarm/dsh-agent-team 0.1.5 → 0.1.7

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

@@ -23,6 +23,18 @@ function emptyProjection() {
 function assertUnhandledKind(operation) {
     throw new Error(`agent-team ledger does not handle operation kind '${operation.kind}'`);
 }
+/** Deep-freeze a Member capability overlay; absent stays absent. */
+function freezeCapabilities(capabilities) {
+    if (capabilities === undefined)
+        return {};
+    const freezeAllow = (allow) => allow === undefined ? {} : { allow: Object.freeze([...allow]) };
+    return {
+        capabilities: Object.freeze({
+            ...(capabilities.tools === undefined ? {} : { tools: Object.freeze(freezeAllow(capabilities.tools.allow)) }),
+            ...(capabilities.skills === undefined ? {} : { skills: Object.freeze(freezeAllow(capabilities.skills.allow)) }),
+        }),
+    };
+}
 /** Replay and append logic behind the Agent Team service interface. */
 export class AgentTeamLedger {
     table;
@@ -85,7 +97,7 @@ export class AgentTeamLedger {
                 this.assertJoinableMember(request.workspaceId, memberId);
             const sequence = this.nextSequence();
             const channel = Object.freeze({
-                channelRef: this.ref('channel'), workspaceId: request.workspaceId, name, description, createdAtSequence: sequence,
+                channelRef: this.ref('channel'), workspaceId: request.workspaceId, name, description, createdAtSequence: sequence, state: 'active',
             });
             const operation = Object.freeze({
                 ...this.operationBase(request, sequence), kind: 'team/channel-created',
@@ -109,7 +121,7 @@ export class AgentTeamLedger {
             const description = request.description.trim();
             if (name === '')
                 throw new Error('channel name must not be empty');
-            const channel = Object.freeze({ ...this.requireChannel(request.workspaceId, request.channelRef), name, description });
+            const channel = Object.freeze({ ...this.requireActiveChannel(request.workspaceId, request.channelRef), name, description });
             const operation = Object.freeze({
                 ...this.operationBase(request, this.nextSequence()), kind: 'team/channel-updated',
                 data: Object.freeze({ workspaceId: request.workspaceId, channel }),
@@ -138,12 +150,14 @@ export class AgentTeamLedger {
             // still drivable through its DM view, and joins Channels later.
             const channelRefs = this.normalizeUnique(request.channelRefs, 'initial Member Channels');
             for (const channelRef of channelRefs)
-                this.requireChannel(request.workspaceId, channelRef);
+                this.requireActiveChannel(request.workspaceId, channelRef);
             this.assertHandleAvailable(request.workspaceId, handle);
             this.assertModelSelection(request.member.model);
+            this.assertCapabilities(request.member.capabilities);
             const member = Object.freeze({
                 ...request.member, handle, description, presetId, state: 'enabled',
                 ...(request.member.model === undefined ? {} : { model: Object.freeze({ ...request.member.model }) }),
+                ...freezeCapabilities(request.member.capabilities),
             });
             const operation = Object.freeze({
                 ...this.operationBase(request, this.nextSequence()), kind: 'team/member-added',
@@ -166,6 +180,8 @@ export class AgentTeamLedger {
             const prior = this.requireMember(request.memberId);
             if (prior.state === 'inactive')
                 throw new Error(`Agent Member '${prior.memberId}' is inactive and can no longer be edited`);
+            if (prior.state === 'archived')
+                throw new Error(`Agent Member '${prior.memberId}' is archived and can no longer be edited`);
             const handle = request.handle.trim();
             const description = request.description.trim();
             if (handle === '')
@@ -173,12 +189,15 @@ export class AgentTeamLedger {
             if (handle !== prior.handle)
                 this.assertHandleAvailable(prior.workspaceId, handle, prior.memberId);
             this.assertModelSelection(request.model);
-            // An absent model must CLEAR any override (inherit the Host default);
-            // spreading `prior` verbatim would silently keep the pinned selection.
-            const { model: _priorModel, ...priorWithoutModel } = prior;
+            this.assertCapabilities(request.capabilities);
+            // An absent model or capabilities field must CLEAR any override
+            // (inherit the Host default / full standard capability surface);
+            // spreading `prior` verbatim would silently keep the pinned value.
+            const { model: _priorModel, capabilities: _priorCapabilities, ...priorWithoutOverlays } = prior;
             const member = Object.freeze({
-                ...priorWithoutModel, handle, description,
+                ...priorWithoutOverlays, handle, description,
                 ...(request.model === undefined ? {} : { model: Object.freeze({ ...request.model }) }),
+                ...freezeCapabilities(request.capabilities),
             });
             const operation = Object.freeze({
                 ...this.operationBase(request, this.nextSequence()), kind: 'team/member-updated',
@@ -238,7 +257,7 @@ export class AgentTeamLedger {
                 return this.resolved(this.joinResult(existing));
             }
             this.assertHumanActor(request.actor);
-            const channel = this.requireChannel(request.workspaceId, request.channelRef);
+            const channel = this.requireActiveChannel(request.workspaceId, request.channelRef);
             const member = this.requireMember(request.memberId);
             if (member.workspaceId !== request.workspaceId)
                 throw new Error('Member and Channel must belong to one Workspace');
@@ -290,6 +309,48 @@ export class AgentTeamLedger {
             return this.committed(this.channelMemberRemovalResult(operation));
         });
     }
+    /**
+     * Archive one Channel: hidden from every surface, facts kept recoverable.
+     * Every active Claim on the Channel's Threads releases with one public
+     * Activity per (owner, Thread), and every Member's Attention and markers
+     * for those Threads clear — a hidden Channel must not leave Tasks stuck in
+     * progress behind it or phantom unread counts.
+     */
+    archiveChannel(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSameChannelArchival(existing, request);
+                return this.resolved(this.channelArchivalResult(existing));
+            }
+            this.assertHumanActor(request.actor);
+            const channel = this.requireChannel(request.workspaceId, request.channelRef);
+            if (channel.state === 'archived')
+                throw new Error(`Channel '${channel.channelRef}' is already archived`);
+            const nextChannel = Object.freeze({ ...channel, state: 'archived' });
+            const threadRefs = this.channelThreadRefs(channel.channelRef);
+            const releasedClaims = [...this.state.claims.values()]
+                .filter(claim => claim.state === 'active' && threadRefs.has(claim.threadRef))
+                .map(claim => Object.freeze({ ...claim, state: 'released' }));
+            const nextClaims = new Map(this.state.claims);
+            for (const claim of releasedClaims)
+                nextClaims.set(claim.claimRef, claim);
+            const sequence = this.nextSequence();
+            const owners = [...new Set(releasedClaims.map(claim => claim.owner))].sort();
+            const activities = Object.freeze(owners.flatMap(owner => this.releaseSummaries(releasedClaims.filter(claim => claim.owner === owner), owner, sequence)));
+            const threads = this.threadsForActivities(activities);
+            const tasks = this.tasksForClaims(releasedClaims, nextClaims);
+            const inbox = this.channelArchivalInbox(threadRefs);
+            const operation = Object.freeze({
+                ...this.operationBase(request, sequence), kind: 'team/channel-archived',
+                data: Object.freeze({ workspaceId: request.workspaceId, channel: nextChannel,
+                    claims: Object.freeze(releasedClaims), activities, tasks, threads, inbox }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            return this.committed(this.channelArchivalResult(operation));
+        });
+    }
     sendMessage(request) {
         return this.enqueue(async () => {
             const recipients = this.normalizeRecipients(request.actor, request.recipients);
@@ -299,7 +360,7 @@ export class AgentTeamLedger {
                 return this.resolved(this.messageResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const channel = this.requireChannel(request.workspaceId, request.channelRef);
+            const channel = this.requireActiveChannel(request.workspaceId, request.channelRef);
             if (actor.kind === 'member')
                 this.requireMemberChannel(this.requireMember(actor.memberId), channel.channelRef);
             const body = request.body.trim();
@@ -572,7 +633,9 @@ export class AgentTeamLedger {
             const activities = this.releaseSummaries(releasedClaims, member.memberId, sequence);
             const threads = this.threadsForActivities(activities);
             const tasks = this.tasksForClaims(releasedClaims, projectedClaims);
-            const threadRefs = new Set([...this.state.tasks.values()].map(task => task.threadRef));
+            // The Member leaves entirely, so Attention and markers clear on every
+            // Thread — taskless ones too — matching the replay validator's scope.
+            const threadRefs = new Set(this.state.threads.keys());
             const inbox = this.removeMemberThreadInbox(member.memberId, threadRefs);
             const operation = Object.freeze({
                 ...this.operationBase(request, sequence), kind: 'team/member-removed',
@@ -584,6 +647,49 @@ export class AgentTeamLedger {
             return this.committed(this.removalResult(operation));
         });
     }
+    /**
+     * Archive one Member: hidden from every surface, data kept recoverable.
+     * The release shape matches removal — active Claims release with public
+     * Activities and the Member's Attention/markers clear — because a hidden
+     * Member must not leave Tasks stuck in progress or phantom unread counts.
+     */
+    archiveMember(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSameArchival(existing, request);
+                return this.resolved(this.archivalResult(existing));
+            }
+            this.assertHumanActor(request.actor);
+            const member = this.requireMember(request.memberId);
+            if (member.state === 'inactive')
+                throw new Error(`Agent Member '${member.memberId}' is already inactive`);
+            if (member.state === 'archived')
+                throw new Error(`Agent Member '${member.memberId}' is already archived`);
+            const nextMember = Object.freeze({ ...member, state: 'archived' });
+            const releasedClaims = [...this.state.claims.values()].filter(claim => claim.owner === member.memberId && claim.state === 'active')
+                .map(claim => Object.freeze({ ...claim, state: 'released' }));
+            const projectedClaims = new Map(this.state.claims);
+            for (const claim of releasedClaims)
+                projectedClaims.set(claim.claimRef, claim);
+            const sequence = this.nextSequence();
+            const activities = this.releaseSummaries(releasedClaims, member.memberId, sequence);
+            const threads = this.threadsForActivities(activities);
+            const tasks = this.tasksForClaims(releasedClaims, projectedClaims);
+            // The Member leaves entirely, so Attention and markers clear on every
+            // Thread — taskless ones too — matching the replay validator's scope.
+            const threadRefs = new Set(this.state.threads.keys());
+            const inbox = this.removeMemberThreadInbox(member.memberId, threadRefs);
+            const operation = Object.freeze({
+                ...this.operationBase(request, sequence), kind: 'team/member-archived',
+                data: Object.freeze({ member: nextMember, claims: Object.freeze(releasedClaims), activities, tasks, threads, inbox }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            this.confirmations.clear();
+            return this.committed(this.archivalResult(operation));
+        });
+    }
     changeAttention(request) {
         return this.enqueue(async () => {
             const existing = this.state.byRequest.get(request.requestId);
@@ -623,6 +729,74 @@ export class AgentTeamLedger {
             return this.committed(this.attentionResult(operation));
         });
     }
+    /**
+     * Append one Member-to-Member direct message as an audit-only operation.
+     * A DM is pure delivery: no Channel, Thread, revision, attention, or
+     * markers change, so apply() is a marker and no projection state moves.
+     */
+    sendDm(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSameDm(existing, request);
+                return this.resolved(this.dmResult(existing));
+            }
+            // Only an enabled Member in this Workspace may send a DM; the Human is
+            // not a sendable peer, and Members in other Workspaces are unreachable.
+            const sender = this.assertActorForWorkspace(request.actor, request.workspaceId);
+            if (sender.kind !== 'member')
+                throw new Error('agent-team DM requires Member authority');
+            const body = request.body.trim();
+            if (body === '')
+                throw new Error('DM body must not be empty');
+            const recipient = this.requireMember(request.recipientMemberId);
+            if (recipient.workspaceId !== request.workspaceId)
+                throw new Error(`Agent Member '${recipient.memberId}' is not in Workspace '${request.workspaceId}'`);
+            if (recipient.state !== 'enabled')
+                throw new Error(`Agent Member '${recipient.memberId}' is ${recipient.state}; DM delivery requires an enabled Member`);
+            if (recipient.memberId === AGENT_TEAM_HUMAN_MEMBER_ID || !recipient.sessionId)
+                throw new Error('DM recipient must be an Agent Member');
+            if (recipient.memberId === sender.memberId)
+                throw new Error('Members cannot DM themselves');
+            const operation = Object.freeze({
+                ...this.operationBase(request, this.nextSequence()), kind: 'team/dm-sent',
+                data: Object.freeze({ workspaceId: request.workspaceId, senderMemberId: sender.memberId,
+                    recipientMemberId: recipient.memberId, body }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            return this.committed(this.dmResult(operation));
+        });
+    }
+    /**
+     * Bounded adjacent context for a DM relay: the truncated body of the most
+     * recent earlier DM between the two sessions, newest first. Returns
+     * undefined when this is their first exchange. `excluding` skips the
+     * operation id of the DM being delivered right now, so the context line is
+     * the adjacent prior exchange rather than a self-reference. Direction
+     * labels are from the reader's perspective: the reader is the recipient of
+     * the DM being delivered, so messages the reader sent are `you → them`.
+     */
+    dmHistoryBetween(senderSessionId, recipientMemberId, excluding) {
+        const sender = [...this.state.members.values()].find(member => member.sessionId === senderSessionId);
+        if (sender === undefined)
+            return undefined;
+        for (let index = this.state.ordered.length - 1; index >= 0; index -= 1) {
+            const operation = this.state.ordered[index];
+            if (operation.kind !== 'team/dm-sent' || operation.operationId === excluding)
+                continue;
+            const pair = operation.data.senderMemberId === sender.memberId && operation.data.recipientMemberId === recipientMemberId;
+            const mirror = operation.data.senderMemberId === recipientMemberId && operation.data.recipientMemberId === sender.memberId;
+            if (!pair && !mirror)
+                continue;
+            // pair: the other Member sent it to the reader → (them → you);
+            // mirror: the reader sent it to the other Member → (you → them).
+            const direction = pair ? 'them → you' : 'you → them';
+            const truncated = operation.data.body.length > 160 ? `${operation.data.body.slice(0, 160)}…` : operation.data.body;
+            return `(${direction}) ${truncated}`;
+        }
+        return undefined;
+    }
     attentionStatus(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
         const { task, thread } = this.threadContextForActor(authorized, request.workspaceId, request);
@@ -773,7 +947,11 @@ export class AgentTeamLedger {
         const resolved = [];
         for (const taskRef of taskRefs) {
             const task = this.state.tasks.get(taskRef);
-            if (task === undefined || this.state.channels.get(task.channelRef)?.workspaceId !== workspaceId)
+            const channel = task === undefined ? undefined : this.state.channels.get(task.channelRef);
+            // Archived Channels do not exist on Team API surfaces: their Tasks stop
+            // resolving, so live message bodies render the refs as plain
+            // non-navigable text through the existing unknown-ref path.
+            if (task === undefined || channel?.workspaceId !== workspaceId || channel?.state === 'archived')
                 continue;
             resolved.push(Object.freeze({ taskRef: task.taskRef, channelRef: task.channelRef, threadRef: task.threadRef, taskNumber: numbers.get(task.taskRef) ?? 0 }));
         }
@@ -795,7 +973,7 @@ export class AgentTeamLedger {
                 throw new Error('Member cannot view another Workspace');
         }
         if (request.channelRef !== undefined) {
-            this.requireChannel(request.workspaceId, request.channelRef);
+            this.requireActiveChannel(request.workspaceId, request.channelRef);
             if (memberId !== undefined && !this.isChannelMember(request.channelRef, memberId))
                 throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${request.channelRef}'`);
         }
@@ -806,12 +984,14 @@ export class AgentTeamLedger {
                 throw new Error(`unknown Thread ref '${request.threadRef}'`);
             if (this.state.channels.get(channelRef)?.workspaceId !== request.workspaceId)
                 throw new Error(`Thread '${request.threadRef}' does not belong to Workspace '${request.workspaceId}'`);
+            this.assertThreadChannelActive(channelRef);
             if (request.channelRef !== undefined && channelRef !== request.channelRef)
                 throw new Error(`Thread '${request.threadRef}' does not belong to Channel '${request.channelRef}'`);
             if (memberId !== undefined && !this.isChannelMember(channelRef, memberId))
                 throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${channelRef}'`);
         }
         const channels = [...this.state.channels.values()].filter(channel => channel.workspaceId === request.workspaceId
+            && channel.state !== 'archived'
             && (memberId === undefined || this.isChannelMember(channel.channelRef, memberId)));
         const channelRefs = new Set(channels.map(channel => channel.channelRef));
         const allFacts = this.state.orderedFacts.filter(fact => {
@@ -846,7 +1026,10 @@ export class AgentTeamLedger {
         return Object.freeze({
             humanMemberId: initialization.data.humanMemberId,
             channels: Object.freeze(channels),
-            members: Object.freeze([...this.state.memberships.entries()].filter(([channelRef]) => channelRefs.has(channelRef)).flatMap(([channelRef, ids]) => [...ids].filter(id => this.state.members.get(id)?.state !== 'inactive').sort().map(memberId => Object.freeze({ channelRef, memberId })))),
+            members: Object.freeze([...this.state.memberships.entries()].filter(([channelRef]) => channelRefs.has(channelRef)).flatMap(([channelRef, ids]) => [...ids].filter(id => {
+                const state = this.state.members.get(id)?.state;
+                return state !== 'inactive' && state !== 'archived';
+            }).sort().map(memberId => Object.freeze({ channelRef, memberId })))),
             tasks: Object.freeze(visibleTasks),
             threads: Object.freeze([...this.state.threads.values()].filter(thread => {
                 const channelRef = this.channelRefForThread(thread.threadRef);
@@ -896,6 +1079,20 @@ export class AgentTeamLedger {
             case 'team/member-updated':
             case 'team/member-removed':
                 return [{ kind: 'workspace', workspaceId: operation.data.member.workspaceId }];
+            case 'team/member-archived': {
+                // Claim releases are thread-visible facts: open Channel and Thread
+                // pages refetch alongside the workspace-wide roster change.
+                const channelByTask = new Map(operation.data.tasks.map(task => [task.taskRef, task.channelRef]));
+                const scopes = [{ kind: 'workspace', workspaceId: operation.data.member.workspaceId }];
+                for (const activity of operation.data.activities) {
+                    scopes.push({ kind: 'thread', threadRef: activity.threadRef });
+                    const channelRef = channelByTask.get(activity.taskRef);
+                    if (channelRef !== undefined && !scopes.some(scope => scope.kind === 'channel' && scope.channelRef === channelRef)) {
+                        scopes.push({ kind: 'channel', channelRef });
+                    }
+                }
+                return scopes;
+            }
             case 'team/channel-member-added':
                 return [{ kind: 'workspace', workspaceId: operation.data.workspaceId }, { kind: 'channel', channelRef: operation.data.channelRef }];
             case 'team/channel-member-removed': {
@@ -913,6 +1110,15 @@ export class AgentTeamLedger {
                 }
                 return scopes;
             }
+            case 'team/channel-archived': {
+                const scopes = [
+                    { kind: 'workspace', workspaceId: operation.data.workspaceId },
+                    { kind: 'channel', channelRef: operation.data.channel.channelRef },
+                ];
+                for (const activity of operation.data.activities)
+                    scopes.push({ kind: 'thread', threadRef: activity.threadRef });
+                return scopes;
+            }
             case 'team/message-sent':
             case 'team/thread-replied':
                 return [{ kind: 'channel', channelRef: operation.data.message.channelRef }, { kind: 'thread', threadRef: operation.data.message.threadRef }];
@@ -929,6 +1135,10 @@ export class AgentTeamLedger {
                 // A read advances only the reader's private watermark; no projection
                 // visible to other participants changes, so nobody is woken.
                 return [];
+            case 'team/dm-sent':
+                // A DM changes no shared projection: delivery is a session-level
+                // runtime effect, so no change waiter has anything to refetch.
+                return [];
             default:
                 return assertUnhandledKind(operation);
         }
@@ -973,7 +1183,9 @@ export class AgentTeamLedger {
             case 'team/thread-attention-changed':
                 return [operation.data.thread.threadRef];
             case 'team/channel-member-removed':
+            case 'team/channel-archived':
             case 'team/member-removed':
+            case 'team/member-archived':
                 return operation.data.activities.map(activity => activity.threadRef);
             case 'team/initialized':
             case 'team/channel-created':
@@ -987,6 +1199,7 @@ export class AgentTeamLedger {
             case 'team/member-updated':
             case 'team/channel-member-added':
             case 'team/thread-read':
+            case 'team/dm-sent':
                 return [];
             default:
                 return assertUnhandledKind(operation);
@@ -1119,7 +1332,8 @@ export class AgentTeamLedger {
             assertHuman();
             const prior = projection.channels.get(operation.data.channel.channelRef);
             if (prior === undefined || prior.workspaceId !== operation.data.workspaceId
-                || operation.data.channel.workspaceId !== prior.workspaceId || operation.data.channel.createdAtSequence !== prior.createdAtSequence) {
+                || operation.data.channel.workspaceId !== prior.workspaceId || operation.data.channel.createdAtSequence !== prior.createdAtSequence
+                || operation.data.channel.state !== prior.state) {
                 throw new Error('invalid Channel update');
             }
             return;
@@ -1127,7 +1341,7 @@ export class AgentTeamLedger {
         if (operation.kind === 'team/member-updated') {
             assertHuman();
             const prior = projection.members.get(operation.data.member.memberId);
-            if (prior === undefined || prior.state === 'inactive' || operation.data.member.state !== prior.state
+            if (prior === undefined || prior.state === 'inactive' || prior.state === 'archived' || operation.data.member.state !== prior.state
                 || operation.data.member.sessionId !== prior.sessionId || operation.data.member.workspaceId !== prior.workspaceId
                 || operation.data.member.presetId !== prior.presetId
                 || operation.data.member.privateMemoryPath !== prior.privateMemoryPath)
@@ -1160,6 +1374,18 @@ export class AgentTeamLedger {
             this.validateReleaseCleanup(operation.data, projection, member.memberId, threadRefs, operation.sequence, refs);
             return;
         }
+        if (operation.kind === 'team/channel-archived') {
+            assertHuman();
+            const prior = projection.channels.get(operation.data.channel.channelRef);
+            if (prior === undefined || prior.state !== 'active' || operation.data.channel.state !== 'archived'
+                || operation.data.channel.workspaceId !== prior.workspaceId || operation.data.workspaceId !== prior.workspaceId
+                || operation.data.channel.name !== prior.name || operation.data.channel.description !== prior.description
+                || operation.data.channel.createdAtSequence !== prior.createdAtSequence)
+                throw new Error('invalid Channel archival');
+            const threadRefs = new Set([...projection.threads.keys()].filter(threadRef => this.channelRefForThreadFrom(projection, threadRef) === prior.channelRef));
+            this.validateChannelArchivalCleanup(operation.data, projection, threadRefs, operation.sequence, refs);
+            return;
+        }
         if (operation.kind === 'team/member-removed') {
             assertHuman();
             const prior = projection.members.get(operation.data.member.memberId);
@@ -1169,6 +1395,15 @@ export class AgentTeamLedger {
             this.validateReleaseCleanup(operation.data, projection, prior.memberId, threadRefs, operation.sequence, refs);
             return;
         }
+        if (operation.kind === 'team/member-archived') {
+            assertHuman();
+            const prior = projection.members.get(operation.data.member.memberId);
+            if (prior === undefined || (prior.state !== 'enabled' && prior.state !== 'suspended') || operation.data.member.state !== 'archived' || !this.sameMemberIdentity(prior, operation.data.member))
+                throw new Error('invalid Member archival');
+            const threadRefs = new Set(projection.threads.keys());
+            this.validateReleaseCleanup(operation.data, projection, prior.memberId, threadRefs, operation.sequence, refs);
+            return;
+        }
         if (operation.kind === 'team/thread-attention-changed') {
             const actor = operation.actor.kind === 'member' ? assertMember() : (assertHuman(), undefined);
             if (operation.data.memberId !== operation.actor.memberId)
@@ -1362,6 +1597,18 @@ export class AgentTeamLedger {
             this.validateInboxDelta(operation.data.inbox, projection, refs, [], [], [activity]);
             return;
         }
+        if (operation.kind === 'team/dm-sent') {
+            const sender = assertMember();
+            const recipient = projection.members.get(operation.data.recipientMemberId);
+            if (recipient === undefined || recipient.workspaceId !== operation.data.workspaceId
+                || recipient.state !== 'enabled' || recipient.memberId === AGENT_TEAM_HUMAN_MEMBER_ID
+                || operation.data.senderMemberId !== sender.memberId
+                || operation.data.recipientMemberId === sender.memberId
+                || operation.data.body.trim() === '' || operation.data.body !== operation.data.body.trim()) {
+                throw new Error('invalid DM operation');
+            }
+            return;
+        }
         assertUnhandledKind(operation);
     }
     validateInboxDelta(delta, projection, _refs, additionalThreadRefs = [], additionalMessages = [], additionalActivities = []) {
@@ -1479,6 +1726,68 @@ export class AgentTeamLedger {
             throw new Error('invalid Member inbox cleanup');
         this.validateInboxDelta(data.inbox, projection, refs);
     }
+    /** Replay validation of one Channel archival's release snapshot across every owner. */
+    validateChannelArchivalCleanup(data, projection, threadRefs, sequence, refs) {
+        const releasedClaims = [...projection.claims.values()]
+            .filter(claim => claim.state === 'active' && threadRefs.has(claim.threadRef))
+            .map(claim => Object.freeze({ ...claim, state: 'released' }));
+        if (data.claims.length !== releasedClaims.length || data.claims.some((claim, index) => {
+            const expected = releasedClaims[index];
+            return expected === undefined || !this.sameClaim(expected, claim);
+        }))
+            throw new Error('invalid released Claim projection');
+        // One activity per (owner, Thread), owners sorted like the commit path.
+        const byOwner = new Map();
+        for (const claim of releasedClaims) {
+            const byThread = byOwner.get(claim.owner) ?? new Map();
+            byOwner.set(claim.owner, byThread);
+            byThread.set(claim.threadRef, [...(byThread.get(claim.threadRef) ?? []), claim]);
+        }
+        const expectedActivities = [...byOwner.keys()].sort().flatMap(owner => [...byOwner.get(owner).entries()].map(([threadRef, claims]) => ({
+            kind: 'claims_released', taskRef: claims[0].taskRef, threadRef, actor: owner, sequence,
+            claimRefs: claims.map(claim => claim.claimRef).sort(),
+        })));
+        if (data.activities.length !== expectedActivities.length || data.activities.some((activity, index) => {
+            const expected = expectedActivities[index];
+            return expected === undefined || activity.kind !== expected.kind || activity.taskRef !== expected.taskRef
+                || activity.threadRef !== expected.threadRef || activity.actor !== expected.actor || activity.sequence !== expected.sequence
+                || !this.sameList(activity.claimRefs, expected.claimRefs);
+        }))
+            throw new Error('invalid released Claim activities');
+        for (const claim of data.claims) {
+            const prior = projection.claims.get(claim.claimRef);
+            if (prior === undefined)
+                throw new Error('invalid released Claim reference');
+        }
+        for (const activity of data.activities)
+            this.addRef(refs, activity.activityRef);
+        const projectedClaims = new Map(projection.claims);
+        for (const claim of releasedClaims)
+            projectedClaims.set(claim.claimRef, claim);
+        const expectedTasks = [...new Set(releasedClaims.map(claim => claim.taskRef))].map(taskRef => {
+            const task = projection.tasks.get(taskRef);
+            return Object.freeze({ ...task, status: this.deriveResolvedTaskStatus(task, projectedClaims.values()) });
+        });
+        const expectedThreads = expectedActivities.map(activity => {
+            const thread = projection.threads.get(activity.threadRef);
+            return Object.freeze({ ...thread, revision: sequence });
+        });
+        if (!isDeepStrictEqual(data.tasks, expectedTasks) || !isDeepStrictEqual(data.threads, expectedThreads)) {
+            throw new Error('invalid released Claim Task or Thread projection');
+        }
+        // Attention and marker cleanup covers EVERY Member on the archived Threads.
+        const expectedAttention = [...projection.attention.values()]
+            .filter(attention => threadRefs.has(attention.threadRef))
+            .map(attention => ({ memberId: attention.memberId, threadRef: attention.threadRef }));
+        const expectedMarkers = [...projection.directMarkers.values()]
+            .filter(marker => threadRefs.has(marker.threadRef));
+        const expectedActivityMarkers = [...projection.activityMarkers.values()]
+            .filter(marker => threadRefs.has(marker.threadRef));
+        const expectedInbox = this.inboxDelta([], expectedAttention, [], expectedMarkers, [], expectedActivityMarkers);
+        if (!isDeepStrictEqual(data.inbox, expectedInbox))
+            throw new Error('invalid Channel archival inbox cleanup');
+        this.validateInboxDelta(data.inbox, projection, refs);
+    }
     validateMessageInbox(operation, projection) {
         const { message, mentions } = operation.data;
         const mentionedAgents = mentions.filter(memberId => projection.members.has(memberId));
@@ -1510,7 +1819,7 @@ export class AgentTeamLedger {
         if (memberId === AGENT_TEAM_HUMAN_MEMBER_ID)
             return true;
         const member = projection.members.get(memberId);
-        return member !== undefined && member.state !== 'inactive'
+        return member !== undefined && member.state !== 'inactive' && member.state !== 'archived'
             && projection.channels.get(channelRef)?.workspaceId === member.workspaceId
             && this.isChannelMemberFrom(projection, channelRef, memberId);
     }
@@ -1577,6 +1886,22 @@ export class AgentTeamLedger {
             this.applyInboxDelta(target, operation.data.inbox);
             return;
         }
+        if (operation.kind === 'team/channel-archived') {
+            // Archival keeps Memberships: hidden state, not departure — a future
+            // restore returns every Member to the Channel. Visibility filters by
+            // channel state instead.
+            target.channels.set(operation.data.channel.channelRef, operation.data.channel);
+            for (const claim of operation.data.claims)
+                target.claims.set(claim.claimRef, claim);
+            for (const activity of operation.data.activities)
+                this.appendActivityFact(target, activity);
+            for (const task of operation.data.tasks)
+                target.tasks.set(task.taskRef, task);
+            for (const thread of operation.data.threads)
+                target.threads.set(thread.threadRef, thread);
+            this.applyInboxDelta(target, operation.data.inbox);
+            return;
+        }
         if (operation.kind === 'team/member-removed') {
             target.members.set(operation.data.member.memberId, operation.data.member);
             for (const membership of target.memberships.values())
@@ -1592,6 +1917,22 @@ export class AgentTeamLedger {
             this.applyInboxDelta(target, operation.data.inbox);
             return;
         }
+        if (operation.kind === 'team/member-archived') {
+            // Archival keeps Memberships: hidden state, not departure — a future
+            // restore returns the Member to its Channels. Visibility filters by
+            // member state instead.
+            target.members.set(operation.data.member.memberId, operation.data.member);
+            for (const claim of operation.data.claims)
+                target.claims.set(claim.claimRef, claim);
+            for (const activity of operation.data.activities)
+                this.appendActivityFact(target, activity);
+            for (const task of operation.data.tasks)
+                target.tasks.set(task.taskRef, task);
+            for (const thread of operation.data.threads)
+                target.threads.set(thread.threadRef, thread);
+            this.applyInboxDelta(target, operation.data.inbox);
+            return;
+        }
         if (operation.kind === 'team/thread-promoted') {
             this.appendActivityFact(target, operation.data.activity);
             target.tasks.set(operation.data.task.taskRef, operation.data.task);
@@ -1633,6 +1974,11 @@ export class AgentTeamLedger {
             this.applyInboxDelta(target, operation.data.inbox);
             return;
         }
+        if (operation.kind === 'team/dm-sent') {
+            // Audit-only: delivery is a transient runtime effect, so the durable
+            // projection deliberately does not change.
+            return;
+        }
         assertUnhandledKind(operation);
     }
     /** Facts arrive in ledger sequence order, so global and per-thread lists stay sorted by append only. */
@@ -1837,6 +2183,14 @@ export class AgentTeamLedger {
         const activityMarkers = [...this.state.activityMarkers.values()].filter(marker => marker.memberId === memberId && threadRefs.has(marker.threadRef));
         return this.inboxDelta([], removed, [], markers, [], activityMarkers);
     }
+    /** Attention and marker cleanup for EVERY Member on the given Threads. */
+    channelArchivalInbox(threadRefs) {
+        const removed = [...this.state.attention.values()].filter(attention => threadRefs.has(attention.threadRef))
+            .map(attention => Object.freeze({ memberId: attention.memberId, threadRef: attention.threadRef }));
+        const markers = [...this.state.directMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
+        const activityMarkers = [...this.state.activityMarkers.values()].filter(marker => threadRefs.has(marker.threadRef));
+        return this.inboxDelta([], removed, [], markers, [], activityMarkers);
+    }
     inboxDelta(set = [], removed = [], addedMarkers = [], removedMarkers = [], addedActivityMarkers = [], removedActivityMarkers = []) {
         return Object.freeze({
             attention: Object.freeze({ set: Object.freeze(set), removed: Object.freeze(removed) }),
@@ -1912,7 +2266,7 @@ export class AgentTeamLedger {
             if (memberId === AGENT_TEAM_HUMAN_MEMBER_ID)
                 continue;
             const member = this.requireMember(memberId);
-            if (member.state === 'inactive' || member.workspaceId !== channel.workspaceId || !this.isChannelMember(channel.channelRef, memberId)) {
+            if (member.state === 'inactive' || member.state === 'archived' || member.workspaceId !== channel.workspaceId || !this.isChannelMember(channel.channelRef, memberId)) {
                 throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${channel.channelRef}'`);
             }
         }
@@ -1963,6 +2317,9 @@ export class AgentTeamLedger {
     threadForActor(actor, workspaceId, taskRef) {
         const task = this.requireTask(workspaceId, taskRef);
         const thread = this.requireThread(task.threadRef);
+        // Archived Channels do not exist on Team API surfaces: their Tasks and
+        // Claims are unreachable for reads (listClaims) as for writes.
+        this.assertThreadChannelActive(task.channelRef);
         if (actor.kind === 'member')
             this.requireMemberChannel(this.requireMember(actor.memberId), task.channelRef);
         return { task, thread };
@@ -2138,6 +2495,13 @@ export class AgentTeamLedger {
             throw new Error(`Thread '${thread.threadRef}' has no Channel`);
         if (projection.channels.get(channelRef)?.workspaceId !== workspaceId)
             throw new Error(`Thread '${thread.threadRef}' does not belong to Workspace '${workspaceId}'`);
+        // Archived Channels do not exist on Team API surfaces: their Threads are
+        // unreachable by ref, for reads as for writes. Replay stays honest —
+        // operations predating the archival resolve against the then-active
+        // Channel because replay applies in sequence.
+        if (projection.channels.get(channelRef)?.state === 'archived') {
+            throw new Error(`Channel '${channelRef}' is archived and no longer accepts Team work`);
+        }
         if (task !== undefined && task.channelRef !== channelRef)
             throw new Error(`Task '${task.taskRef}' does not belong to Thread '${thread.threadRef}'`);
         return { ...(task === undefined ? {} : { task }), thread, channelRef };
@@ -2150,6 +2514,19 @@ export class AgentTeamLedger {
             throw new Error(`Channel '${channelRef}' does not belong to Workspace '${workspaceId}'`);
         return channel;
     }
+    /** Guard for every mutating or Channel-scoped surface flow: archived Channels reject. */
+    requireActiveChannel(workspaceId, channelRef) {
+        const channel = this.requireChannel(workspaceId, channelRef);
+        if (channel.state === 'archived')
+            throw new Error(`Channel '${channelRef}' is archived and no longer accepts Team work`);
+        return channel;
+    }
+    /** Thread-mutation guard: the Channel owning the Thread must still be active. */
+    assertThreadChannelActive(channelRef) {
+        if (this.state.channels.get(channelRef)?.state === 'archived') {
+            throw new Error(`Channel '${channelRef}' is archived and no longer accepts Team work`);
+        }
+    }
     requireMember(memberId) {
         const member = this.state.members.get(memberId);
         if (member === undefined)
@@ -2206,6 +2583,20 @@ export class AgentTeamLedger {
         if (model.provider.trim() === '' || model.model.trim() === '')
             throw new Error('member model selection must name a provider route and a model id');
     }
+    /**
+     * Capability allow-list entries are exact identifiers (skill names,
+     * reserved tool names); only whitespace-only values are rejected. Unknown
+     * names are intent, not errors — committing must stay replayable across
+     * Harness upgrades, so divergence is derived at activation instead.
+     */
+    assertCapabilities(capabilities) {
+        for (const surface of [capabilities?.tools?.allow, capabilities?.skills?.allow]) {
+            if (surface === undefined)
+                continue;
+            if (surface.some(name => name.trim() === ''))
+                throw new Error('capability allow-list names must not be empty');
+        }
+    }
     initialization() {
         const operation = this.state.ordered[0];
         if (operation === undefined)
@@ -2234,6 +2625,7 @@ export class AgentTeamLedger {
             || operation.data.member.workspaceId !== request.workspaceId || operation.data.member.handle !== request.handle.trim()
             || operation.data.member.description !== request.description.trim() || operation.data.member.presetId !== request.presetId.trim()
             || !isDeepStrictEqual(operation.data.member.model ?? undefined, request.member.model ?? undefined)
+            || !isDeepStrictEqual(operation.data.member.capabilities ?? undefined, request.member.capabilities ?? undefined)
             || !this.sameList(operation.data.channelRefs, this.normalizeUnique(request.channelRefs, 'initial Member Channels')))
             this.throwRequestCollision(request.requestId);
     }
@@ -2257,7 +2649,8 @@ export class AgentTeamLedger {
         if (operation.kind !== 'team/member-updated' || !this.sameActor(operation.actor, request.actor)
             || operation.data.member.memberId !== request.memberId || operation.data.member.handle !== request.handle.trim()
             || operation.data.member.description !== request.description.trim()
-            || !isDeepStrictEqual(operation.data.member.model ?? undefined, request.model ?? undefined))
+            || !isDeepStrictEqual(operation.data.member.model ?? undefined, request.model ?? undefined)
+            || !isDeepStrictEqual(operation.data.member.capabilities ?? undefined, request.capabilities ?? undefined))
             this.throwRequestCollision(request.requestId);
     }
     assertSameChannelJoin(operation, request) {
@@ -2270,6 +2663,22 @@ export class AgentTeamLedger {
             || operation.data.workspaceId !== request.workspaceId || operation.data.channelRef !== request.channelRef || operation.data.memberId !== request.memberId)
             this.throwRequestCollision(request.requestId);
     }
+    assertSameChannelArchival(operation, request) {
+        if (operation.kind !== 'team/channel-archived' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.workspaceId !== request.workspaceId || operation.data.channel.channelRef !== request.channelRef)
+            this.throwRequestCollision(request.requestId);
+    }
+    assertSameDm(operation, request) {
+        if (operation.kind !== 'team/dm-sent' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.workspaceId !== request.workspaceId
+            || operation.data.senderMemberId !== request.actor.memberId
+            || operation.data.recipientMemberId !== request.recipientMemberId
+            || operation.data.body !== request.body.trim())
+            this.throwRequestCollision(request.requestId);
+    }
+    dmResult(operation) {
+        return Object.freeze({ receipt: this.receipt(operation), recipient: this.requireMember(operation.data.recipientMemberId) });
+    }
     assertSameMessage(operation, request, recipients) {
         if (operation.kind !== 'team/message-sent' || !this.sameActor(operation.actor, request.actor)
             || operation.data.workspaceId !== request.workspaceId || operation.data.message.channelRef !== request.channelRef
@@ -2314,6 +2723,11 @@ export class AgentTeamLedger {
             || operation.data.member.memberId !== request.memberId)
             this.throwRequestCollision(request.requestId);
     }
+    assertSameArchival(operation, request) {
+        if (operation.kind !== 'team/member-archived' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.member.memberId !== request.memberId)
+            this.throwRequestCollision(request.requestId);
+    }
     assertSameAttention(operation, request) {
         if (operation.kind !== 'team/thread-attention-changed' || !this.sameActor(operation.actor, request.actor)
             || operation.data.workspaceId !== request.workspaceId
@@ -2404,6 +2818,10 @@ export class AgentTeamLedger {
         return Object.freeze({ receipt: this.receipt(operation), channelRef: operation.data.channelRef, memberId: operation.data.memberId,
             releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
     }
+    channelArchivalResult(operation) {
+        return Object.freeze({ receipt: this.receipt(operation), channel: operation.data.channel,
+            releasedClaims: operation.data.claims });
+    }
     messageResult(operation) {
         return Object.freeze(this.committedMessageResult(operation));
     }
@@ -2444,6 +2862,10 @@ export class AgentTeamLedger {
         return Object.freeze({ receipt: this.receipt(operation), member: operation.data.member,
             releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
     }
+    archivalResult(operation) {
+        return Object.freeze({ receipt: this.receipt(operation), member: operation.data.member,
+            releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
+    }
     operationBase(request, sequence) {
         return { sequence, operationId: this.createOperationId(), requestId: request.requestId, occurredAt: this.createOccurredAt(),
             actor: Object.freeze({ ...request.actor }), previousOperationId: this.state.ordered.at(-1)?.operationId ?? null };