@wowyuarm/dsh-agent-team 0.1.1 → 0.1.3

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

@@ -19,6 +19,10 @@ function emptyProjection() {
         orderedFacts: [], factsByThread: new Map(), topLevelMessages: [], mentionsByMessage: new Map(), messageCountByThread: new Map(),
         attentionByThread: new Map() };
 }
+/** Exhaustiveness guard for the closed operation union: adding a kind must update every dispatch. */
+function assertUnhandledKind(operation) {
+    throw new Error(`agent-team ledger does not handle operation kind '${operation.kind}'`);
+}
 /** Replay and append logic behind the Agent Team service interface. */
 export class AgentTeamLedger {
     table;
@@ -191,31 +195,6 @@ export class AgentTeamLedger {
     resumeMember(request) {
         return this.setMemberState(request, 'enabled');
     }
-    /**
-     * Audit record of one in-place Member session restart. The operation changes
-     * no projection state — identity, transcript, and memory are untouched — so
-     * replay treats it as a marker while the Host re-mints the live handle.
-     */
-    restartMember(request) {
-        return this.enqueue(async () => {
-            const existing = this.state.byRequest.get(request.requestId);
-            if (existing !== undefined) {
-                this.assertSameMemberRestart(existing, request);
-                return this.resolved(this.memberResult(existing));
-            }
-            this.assertHumanActor(request.actor);
-            const member = this.requireMember(request.memberId);
-            if (member.state !== 'enabled')
-                throw new Error(`Agent Member '${member.handle}' is ${member.state}; only enabled Members can be restarted`);
-            const operation = Object.freeze({
-                ...this.operationBase(request, this.nextSequence()), kind: 'team/member-session-restarted',
-                data: Object.freeze({ member }),
-            });
-            await this.table.put(operation.operationId, operation);
-            this.apply(operation);
-            return this.committed(this.memberResult(operation));
-        });
-    }
     getMember(memberId) {
         return this.state.members.get(memberId);
     }
@@ -335,19 +314,14 @@ export class AgentTeamLedger {
                 return this.resolved(this.replyResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const task = this.requireTask(request.workspaceId, request.taskRef);
-            const thread = this.requireThread(task.threadRef);
-            if (actor.kind === 'member')
-                this.requireMemberChannel(this.requireMember(actor.memberId), task.channelRef);
+            const { task, thread } = this.threadForActor(actor, request.workspaceId, request.taskRef);
             const body = request.body.trim();
             if (body === '')
                 throw new Error('message body must not be empty');
             this.assertMentionTargets(this.requireChannel(request.workspaceId, task.channelRef), recipients);
-            const unread = this.unreadFor(actor.memberId, thread.threadRef);
-            if (unread.length > 0)
-                return this.resolved(this.unreadRequired(task, thread, unread));
-            if (request.baseRevision !== thread.revision)
-                return this.resolved(this.staleRevision(task, thread, request.baseRevision));
+            const deferred = this.deferredThreadWrite(actor.memberId, task, thread, request.baseRevision);
+            if (deferred !== undefined)
+                return this.resolved(deferred);
             if (task.resolution === 'closed')
                 throw new Error(`Task '${task.taskRef}' is closed; reopen it before replying`);
             const unfollowedAgents = recipients.filter(memberId => this.state.members.has(memberId) && !this.isFollowing(thread.threadRef, memberId));
@@ -389,15 +363,10 @@ export class AgentTeamLedger {
                 return this.resolved(this.claimResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const task = this.requireTask(request.workspaceId, request.taskRef);
-            const thread = this.requireThread(task.threadRef);
-            if (actor.kind === 'member')
-                this.requireMemberChannel(this.requireMember(actor.memberId), task.channelRef);
-            const unread = this.unreadFor(actor.memberId, thread.threadRef);
-            if (unread.length > 0)
-                return this.resolved(this.unreadRequired(task, thread, unread));
-            if (request.baseRevision !== thread.revision)
-                return this.resolved(this.staleRevision(task, thread, request.baseRevision));
+            const { task, thread } = this.threadForActor(actor, request.workspaceId, request.taskRef);
+            const deferred = this.deferredThreadWrite(actor.memberId, task, thread, request.baseRevision);
+            if (deferred !== undefined)
+                return this.resolved(deferred);
             if (task.resolution !== 'open')
                 throw new Error(`Task '${task.taskRef}' is ${task.status}; reopen it before changing Claims`);
             if (actor.kind !== 'member')
@@ -466,24 +435,32 @@ export class AgentTeamLedger {
                 return this.resolved(this.taskResult(existing));
             }
             this.assertHumanActor(request.actor);
-            const task = this.requireTask(request.workspaceId, request.taskRef);
-            const thread = this.requireThread(task.threadRef);
-            const unread = this.unreadFor(request.actor.memberId, thread.threadRef);
-            if (unread.length > 0)
-                return this.resolved(this.unreadRequired(task, thread, unread));
-            if (request.baseRevision !== thread.revision)
-                return this.resolved(this.staleRevision(task, thread, request.baseRevision));
+            const { task, thread } = this.threadForActor(request.actor, request.workspaceId, request.taskRef);
+            const deferred = this.deferredThreadWrite(request.actor.memberId, task, thread, request.baseRevision);
+            if (deferred !== undefined)
+                return this.resolved(deferred);
             if (request.action === 'accept' && task.resolution !== 'open')
                 throw new Error(`Task '${task.taskRef}' is already ${task.resolution}`);
             if (request.action === 'close' && task.resolution === 'closed')
                 throw new Error(`Task '${task.taskRef}' is already closed`);
-            if (request.action === 'accept' && task.status !== 'in_review')
-                throw new Error(`Task '${task.taskRef}' must be in_review before acceptance`);
+            // Acceptance normally waits for every Claim to finish (in_review);
+            // a Human may also accept early while work is in progress, which then
+            // completes the still-active Claims inside the same atomic operation.
+            if (request.action === 'accept' && task.status !== 'in_review' && task.status !== 'in_progress') {
+                throw new Error(`Task '${task.taskRef}' must be in_review or in_progress before acceptance`);
+            }
+            const priorActiveClaims = [...this.state.claims.values()].filter(claim => claim.taskRef === task.taskRef && claim.state === 'active');
+            if (request.action === 'accept' && task.status === 'in_progress' && priorActiveClaims.length === 0) {
+                throw new Error(`Task '${task.taskRef}' has no active Claims to complete for early acceptance`);
+            }
             if (request.action === 'reopen' && task.resolution === 'open')
                 throw new Error(`Task '${task.taskRef}' is already open`);
             const sequence = this.nextSequence();
-            const claims = [...this.state.claims.values()].filter(claim => claim.taskRef === task.taskRef).map(claim => request.action === 'close' && claim.state === 'active' ? Object.freeze({ ...claim, state: 'released' }) : claim);
+            const claims = [...this.state.claims.values()].filter(claim => claim.taskRef === task.taskRef).map(claim => request.action === 'close' && claim.state === 'active' ? Object.freeze({ ...claim, state: 'released' })
+                : request.action === 'accept' && claim.state === 'active' ? Object.freeze({ ...claim, state: 'done' })
+                    : claim);
             const releasedClaims = claims.filter(claim => claim.state === 'released' && this.state.claims.get(claim.claimRef)?.state === 'active');
+            const completedClaims = claims.filter(claim => claim.state === 'done' && this.state.claims.get(claim.claimRef)?.state === 'active');
             const resolution = request.action === 'reopen' ? 'open' : request.action === 'accept' ? 'accepted' : 'closed';
             const status = resolution === 'accepted' ? 'done' : resolution === 'closed' ? 'closed'
                 : this.deriveTaskStatus(task.taskRef, claims);
@@ -491,12 +468,13 @@ export class AgentTeamLedger {
             const nextThread = Object.freeze({ ...thread, revision: sequence });
             const activity = Object.freeze({ activityRef: this.ref('activity'), kind: request.action,
                 taskRef: task.taskRef, threadRef: task.threadRef, actor: request.actor.memberId, sequence,
-                ...(releasedClaims.length === 0 ? {} : { releasedClaimRefs: Object.freeze(releasedClaims.map(claim => claim.claimRef)) }) });
+                ...(releasedClaims.length === 0 ? {} : { releasedClaimRefs: Object.freeze(releasedClaims.map(claim => claim.claimRef)) }),
+                ...(completedClaims.length === 0 ? {} : { completedClaimRefs: Object.freeze(completedClaims.map(claim => claim.claimRef)) }) });
             const inbox = request.action === 'close'
                 ? this.closeThreadInbox(activity, thread.threadRef)
                 : request.action === 'reopen'
                     ? this.reopenThreadInbox(activity, thread.threadRef)
-                    : this.inboxDelta();
+                    : this.acceptThreadInbox(activity, thread.threadRef, completedClaims.map(claim => claim.owner));
             const operation = Object.freeze({
                 ...this.operationBase(request, sequence), kind: 'team/task-changed',
                 data: Object.freeze({ workspaceId: request.workspaceId, baseRevision: request.baseRevision,
@@ -548,10 +526,7 @@ export class AgentTeamLedger {
                 return this.resolved(this.attentionResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const task = this.requireTask(request.workspaceId, request.taskRef);
-            const thread = this.requireThread(task.threadRef);
-            if (actor.kind === 'member')
-                this.requireMemberChannel(this.requireMember(actor.memberId), task.channelRef);
+            const { task, thread } = this.threadForActor(actor, request.workspaceId, request.taskRef);
             const current = this.attentionFor(actor.memberId, thread.threadRef);
             if (request.action === 'follow') {
                 if (task.resolution === 'closed')
@@ -584,10 +559,7 @@ export class AgentTeamLedger {
     }
     attentionStatus(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const task = this.requireTask(request.workspaceId, request.taskRef);
-        if (authorized.kind === 'member')
-            this.requireMemberChannel(this.requireMember(authorized.memberId), task.channelRef);
-        const thread = this.requireThread(task.threadRef);
+        const { task, thread } = this.threadForActor(authorized, request.workspaceId, request.taskRef);
         const attention = this.attentionFor(authorized.memberId, thread.threadRef);
         return attention === undefined
             ? Object.freeze({ task, thread })
@@ -688,22 +660,9 @@ export class AgentTeamLedger {
         }
         return Object.freeze({ items: Object.freeze(observations.slice(-limit)) });
     }
+    /** Every operation carrying an inbox delta drives the Inbox projection; the payload shape decides, not a per-kind list. */
     attentionDelta(operation) {
-        switch (operation.kind) {
-            case 'team/channel-member-removed':
-            case 'team/message-sent':
-            case 'team/thread-replied':
-            case 'team/claim-created':
-            case 'team/claim-done':
-            case 'team/claim-released':
-            case 'team/task-changed':
-            case 'team/thread-attention-changed':
-            case 'team/thread-read':
-            case 'team/member-removed':
-                return operation.data.inbox;
-            default:
-                return undefined;
-        }
+        return 'inbox' in operation.data ? operation.data.inbox : undefined;
     }
     /** Attachment ids referenced by any stored Message — the GC's keep-set oracle. */
     referencedAttachmentIds() {
@@ -718,10 +677,7 @@ export class AgentTeamLedger {
     }
     threadHistory(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const task = this.requireTask(request.workspaceId, request.taskRef);
-        if (authorized.kind === 'member')
-            this.requireMemberChannel(this.requireMember(authorized.memberId), task.channelRef);
-        const thread = this.requireThread(task.threadRef);
+        const { task, thread } = this.threadForActor(authorized, request.workspaceId, request.taskRef);
         const limit = request.limit ?? 20;
         if (!Number.isInteger(limit) || limit < 1 || limit > 100)
             throw new Error('history limit must be an integer between 1 and 100');
@@ -737,14 +693,27 @@ export class AgentTeamLedger {
     }
     listClaims(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const task = this.requireTask(request.workspaceId, request.taskRef);
-        if (authorized.kind === 'member')
-            this.requireMemberChannel(this.requireMember(authorized.memberId), task.channelRef);
-        return Object.freeze({ task, thread: this.requireThread(task.threadRef), claims: this.claimsForTask(task.taskRef) });
+        const { task, thread } = this.threadForActor(authorized, request.workspaceId, request.taskRef);
+        return Object.freeze({ task, thread, claims: this.claimsForTask(task.taskRef) });
     }
     getTask(taskRef) {
         return this.state.tasks.get(taskRef);
     }
+    getClaim(claimRef) {
+        return this.state.claims.get(claimRef);
+    }
+    /** Navigation facts for message-body Task refs; unknown refs are omitted. */
+    resolveTaskRefs(workspaceId, taskRefs) {
+        const numbers = this.taskNumbers(workspaceId);
+        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)
+                continue;
+            resolved.push(Object.freeze({ taskRef: task.taskRef, channelRef: task.channelRef, threadRef: task.threadRef, taskNumber: numbers.get(task.taskRef) ?? 0 }));
+        }
+        return resolved;
+    }
     view(request, memberId) {
         const limit = request.limit ?? 20;
         const direction = request.direction ?? 'after';
@@ -794,7 +763,7 @@ export class AgentTeamLedger {
         const visibleTasks = [...this.state.tasks.values()].filter(task => channelRefs.has(task.channelRef)
             && (request.channelRef === undefined || task.channelRef === request.channelRef)
             && (request.threadRef === undefined || task.threadRef === request.threadRef));
-        const taskNumbers = this.taskNumbers(request.workspaceId, request.channelRef);
+        const taskNumbers = this.taskNumbers(request.workspaceId);
         const items = selected.filter((fact) => fact.kind === 'message').map(fact => {
             const message = fact.message;
             const task = this.requireTask(request.workspaceId, message.taskRef);
@@ -881,6 +850,8 @@ export class AgentTeamLedger {
                 // A read advances only the reader's private watermark; no projection
                 // visible to other participants changes, so nobody is woken.
                 return [];
+            default:
+                return assertUnhandledKind(operation);
         }
     }
     /** Members whose Inbox projection may have changed; the Host notifies only live ones. */
@@ -923,8 +894,19 @@ export class AgentTeamLedger {
             case 'team/channel-member-removed':
             case 'team/member-removed':
                 return operation.data.activities.map(activity => activity.threadRef);
-            default:
+            case 'team/initialized':
+            case 'team/channel-created':
+            case 'team/channel-updated':
+            case 'team/member-added':
+            case 'team/member-suspended':
+            case 'team/member-resumed':
+            case 'team/member-session-restarted':
+            case 'team/member-updated':
+            case 'team/channel-member-added':
+            case 'team/thread-read':
                 return [];
+            default:
+                return assertUnhandledKind(operation);
         }
     }
     replay() {
@@ -1001,7 +983,7 @@ export class AgentTeamLedger {
         if (operation.kind === 'team/member-added') {
             assertHuman();
             const { member, channelRefs } = operation.data;
-            if (projection.members.has(member.memberId) || channelRefs.length === 0 || new Set(channelRefs).size !== channelRefs.length)
+            if (projection.members.has(member.memberId) || new Set(channelRefs).size !== channelRefs.length)
                 throw new Error('invalid Member creation');
             this.addRef(refs, member.memberId);
             for (const channelRef of channelRefs) {
@@ -1202,12 +1184,18 @@ export class AgentTeamLedger {
             const expectedResolution = activity.kind === 'accept' ? 'accepted' : activity.kind === 'close' ? 'closed' : 'open';
             const expectedStatus = expectedResolution === 'accepted' ? 'done' : expectedResolution === 'closed' ? 'closed'
                 : this.deriveTaskStatus(task.taskRef, operation.data.claims);
+            const expectedCompletedClaimRefs = operation.data.claims
+                .filter(claim => projection.claims.get(claim.claimRef)?.state === 'active' && claim.state === 'done')
+                .map(claim => claim.claimRef);
             if (task.resolution !== expectedResolution || task.status !== expectedStatus
                 || (activity.kind !== 'close' && activity.releasedClaimRefs !== undefined)
+                || (activity.kind !== 'accept' && activity.completedClaimRefs !== undefined)
                 || (activity.kind === 'close' && !this.sameList(activity.releasedClaimRefs ?? [], operation.data.claims
                     .filter(claim => projection.claims.get(claim.claimRef)?.state === 'active' && claim.state === 'released')
-                    .map(claim => claim.claimRef))))
+                    .map(claim => claim.claimRef)))
+                || !this.sameList(activity.completedClaimRefs ?? [], expectedCompletedClaimRefs)) {
                 throw new Error('invalid Task state transition');
+            }
             const priorClaims = [...projection.claims.values()].filter(claim => claim.taskRef === task.taskRef).sort((left, right) => left.claimRef.localeCompare(right.claimRef));
             const operationClaims = [...operation.data.claims].sort((left, right) => left.claimRef.localeCompare(right.claimRef));
             if (priorClaims.length !== operationClaims.length || priorClaims.some((claim, index) => claim.claimRef !== operationClaims[index]?.claimRef))
@@ -1218,7 +1206,9 @@ export class AgentTeamLedger {
                     throw new Error('invalid Task Claim identity');
                 const legal = activity.kind === 'close'
                     ? (previousClaim.state === 'active' ? claim.state === 'released' : claim.state === previousClaim.state)
-                    : claim.state === previousClaim.state;
+                    : activity.kind === 'accept'
+                        ? (previousClaim.state === 'active' ? claim.state === 'done' : claim.state === previousClaim.state)
+                        : claim.state === previousClaim.state;
                 if (!legal)
                     throw new Error('invalid Task Claim transition');
             }
@@ -1227,12 +1217,13 @@ export class AgentTeamLedger {
                 ? this.closeThreadInboxFrom(projection, activity, thread.threadRef)
                 : activity.kind === 'reopen'
                     ? this.reopenThreadInboxFrom(projection, activity, thread.threadRef)
-                    : this.inboxDelta();
+                    : this.acceptThreadInboxFrom(projection, activity, thread.threadRef, expectedCompletedClaimRefs);
             if (!isDeepStrictEqual(operation.data.inbox, expectedInbox))
                 throw new Error('invalid Task inbox projection');
             this.validateInboxDelta(operation.data.inbox, projection, refs, [], [], [activity]);
             return;
         }
+        assertUnhandledKind(operation);
     }
     validateInboxDelta(delta, projection, _refs, additionalThreadRefs = [], additionalMessages = [], additionalActivities = []) {
         const attentionKeys = new Set();
@@ -1482,7 +1473,9 @@ export class AgentTeamLedger {
         }
         if (operation.kind === 'team/thread-attention-changed' || operation.kind === 'team/thread-read') {
             this.applyInboxDelta(target, operation.data.inbox);
+            return;
         }
+        assertUnhandledKind(operation);
     }
     /** Facts arrive in ledger sequence order, so global and per-thread lists stay sorted by append only. */
     appendMessageFact(target, message, mentions) {
@@ -1648,6 +1641,25 @@ export class AgentTeamLedger {
             activityRef: activity.activityRef, sequence: activity.sequence }));
         return this.inboxDelta([], removed, [], [...projection.directMarkers.values()].filter(marker => marker.threadRef === threadRef), activityMarkers, [...projection.activityMarkers.values()].filter(marker => marker.threadRef === threadRef));
     }
+    /**
+     * Early acceptance completes open Claims inside the accept operation; their
+     * owners learn about it through activity markers regardless of whether they
+     * still follow the Thread. Plain accepts (no completed Claims) stay silent.
+     */
+    acceptThreadInbox(activity, threadRef, completedOwners) {
+        if (completedOwners.length === 0)
+            return this.inboxDelta();
+        const recipients = [...new Set(completedOwners)].filter(memberId => memberId !== activity.actor);
+        const markers = recipients.map(memberId => Object.freeze({ memberId, threadRef,
+            activityRef: activity.activityRef, sequence: activity.sequence }));
+        return this.inboxDelta([], [], [], [], markers);
+    }
+    acceptThreadInboxFrom(projection, activity, threadRef, completedClaimRefs) {
+        if (completedClaimRefs.length === 0)
+            return this.inboxDelta();
+        const owners = completedClaimRefs.map(claimRef => projection.claims.get(claimRef)?.owner).filter(owner => owner !== undefined);
+        return this.acceptThreadInbox(activity, threadRef, owners);
+    }
     reopenThreadInbox(activity, threadRef) {
         return this.reopenThreadInboxFrom(this.state, activity, threadRef);
     }
@@ -1787,6 +1799,29 @@ export class AgentTeamLedger {
             return Object.freeze({ ...task, status: this.deriveResolvedTaskStatus(task, projected.values()) });
         }));
     }
+    /** Resolve one Task's Thread for a workspace-authorized actor; Member actors must belong to the Task's Channel. */
+    threadForActor(actor, workspaceId, taskRef) {
+        const task = this.requireTask(workspaceId, taskRef);
+        const thread = this.requireThread(task.threadRef);
+        if (actor.kind === 'member')
+            this.requireMemberChannel(this.requireMember(actor.memberId), task.channelRef);
+        return { task, thread };
+    }
+    /** Business outcomes that defer a thread write: unread work first, then a stale revision. */
+    deferredThreadWrite(actorMemberId, task, thread, baseRevision) {
+        const unread = this.unreadFor(actorMemberId, thread.threadRef);
+        if (unread.length > 0)
+            return this.unreadRequired(task, thread, unread);
+        if (baseRevision !== thread.revision)
+            return this.staleRevision(task, thread, baseRevision);
+        return undefined;
+    }
+    /** Commit projections shared by the Message-sent and Thread-replied results. */
+    committedMessageResult(operation) {
+        return { kind: 'committed', receipt: this.receipt(operation), message: operation.data.message,
+            task: operation.data.task, thread: operation.data.thread, attention: operation.data.inbox.attention.set,
+            directMarkers: operation.data.inbox.directMarkers.added };
+    }
     threadAnchor(task) {
         return this.threadAnchorFrom(this.state, task);
     }
@@ -1799,16 +1834,21 @@ export class AgentTeamLedger {
     threadFactKey(fact) {
         return fact.kind === 'message' ? `message:${fact.message.messageRef}` : `activity:${fact.activity.activityRef}`;
     }
-    taskNumbers(workspaceId, channelRef) {
+    /**
+     * Display numbers for Tasks: one counter per home Channel, in creation
+     * order. This is the single numbering authority — Channel cards, Thread
+     * headings, cross-channel ref resolution, and inbox renders all show the
+     * ordinal the Task holds inside its own Channel.
+     */
+    taskNumbers(workspaceId) {
         const numbers = new Map();
-        let next = 1;
+        const next = new Map();
         for (const message of this.state.topLevelMessages) {
             if (this.state.channels.get(message.channelRef)?.workspaceId !== workspaceId)
                 continue;
-            if (channelRef !== undefined && message.channelRef !== channelRef)
-                continue;
-            numbers.set(message.taskRef, next);
-            next += 1;
+            const ordinal = (next.get(message.channelRef) ?? 0) + 1;
+            next.set(message.channelRef, ordinal);
+            numbers.set(message.taskRef, ordinal);
         }
         return numbers;
     }
@@ -1987,11 +2027,6 @@ export class AgentTeamLedger {
             || !this.sameList(operation.data.channelRefs, this.normalizeUnique(request.channelRefs, 'initial Member Channels')))
             this.throwRequestCollision(request.requestId);
     }
-    assertSameMemberRestart(operation, request) {
-        if (operation.kind !== 'team/member-session-restarted' || !this.sameActor(operation.actor, request.actor)
-            || operation.data.member.memberId !== request.memberId)
-            this.throwRequestCollision(request.requestId);
-    }
     assertSameMemberState(operation, request, state) {
         const kind = state === 'suspended' ? 'team/member-suspended' : 'team/member-resumed';
         if (operation.kind !== kind || !this.sameActor(operation.actor, request.actor) || operation.data.member.memberId !== request.memberId)
@@ -2129,14 +2164,10 @@ export class AgentTeamLedger {
             releasedClaims: operation.data.claims, removedAttention: operation.data.inbox.attention.removed });
     }
     messageResult(operation) {
-        return Object.freeze({ kind: 'committed', receipt: this.receipt(operation), message: operation.data.message,
-            task: operation.data.task, thread: operation.data.thread, attention: operation.data.inbox.attention.set,
-            directMarkers: operation.data.inbox.directMarkers.added });
+        return Object.freeze(this.committedMessageResult(operation));
     }
     replyResult(operation) {
-        return Object.freeze({ kind: 'committed', receipt: this.receipt(operation), message: operation.data.message,
-            task: operation.data.task, thread: operation.data.thread, attention: operation.data.inbox.attention.set,
-            directMarkers: operation.data.inbox.directMarkers.added });
+        return Object.freeze(this.committedMessageResult(operation));
     }
     claimResult(operation) {
         const attention = operation.data.inbox.attention.set.find(candidate => candidate.memberId === operation.data.claim.owner);

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

@@ -8,59 +8,55 @@ export function classifyRecoverableError(message) {
     return undefined;
 }
 export const RECOVERY_DELAY_MS = 120_000;
-export const RECOVERY_MAX_ATTEMPTS = 3;
+export const RECOVERY_MAX_CONSECUTIVE_ERRORS = 3;
 /**
- * Per-member automatic recovery episodes. One episode covers a run of
- * identical errors; a changed error string starts a fresh one, and any clean
- * turn end clears the slate. After `maxAttempts` injections of the same error
- * the coordinator stands down and leaves the Member in error for the operator.
+ * Per-member automatic recovery episodes. An episode is every recoverable
+ * `agent/error` occurrence until a clean turn end, regardless of error text
+ * or family. Each of the first two occurrences schedules its own wakeup.
  */
 export class RecoveryCoordinator {
     episodes = new Map();
-    inject;
+    wake;
     onStandDown;
     delayMs;
-    maxAttempts;
+    maxConsecutiveErrors;
     constructor(options) {
-        this.inject = options.inject;
+        this.wake = options.wake;
         this.onStandDown = options.onStandDown;
         this.delayMs = options.delayMs ?? RECOVERY_DELAY_MS;
-        this.maxAttempts = options.maxAttempts ?? RECOVERY_MAX_ATTEMPTS;
+        this.maxConsecutiveErrors = options.maxConsecutiveErrors ?? RECOVERY_MAX_CONSECUTIVE_ERRORS;
     }
-    /** Observe one error occurrence for a Member. */
+    /** Observe one `agent/error` occurrence for a Member. */
     onError(memberId, errorMessage) {
-        const kind = classifyRecoverableError(errorMessage);
-        if (kind === undefined) {
-            // A non-retryable failure cancels anything pending: retrying cannot help.
+        if (classifyRecoverableError(errorMessage) === undefined) {
+            // A non-recoverable failure cancels anything pending: retrying cannot help.
             this.stopTracking(memberId);
             return;
         }
         let episode = this.episodes.get(memberId);
-        if (episode === undefined || episode.lastError !== errorMessage) {
-            this.cancelTimer(episode);
-            episode = { kind, lastError: errorMessage, attempts: 0 };
+        if (episode === undefined) {
+            episode = { consecutiveFailures: 0, timers: new Set() };
             this.episodes.set(memberId, episode);
         }
-        else if (episode.attempts >= this.maxAttempts) {
-            // The same error survived every allowed injection — stand down once.
-            if (episode.stoodDown !== true) {
-                episode.stoodDown = true;
-                this.onStandDown?.(memberId, episode.attempts);
-            }
+        if (episode.stoodDown === true)
             return;
-        }
-        if (episode.timer !== undefined)
+        episode.consecutiveFailures += 1;
+        if (episode.consecutiveFailures >= this.maxConsecutiveErrors) {
+            this.cancelTimers(episode);
+            episode.stoodDown = true;
+            this.onStandDown?.(memberId, episode.consecutiveFailures);
             return;
-        episode.timer = setTimeout(() => {
-            episode.timer = undefined;
-            episode.attempts += 1;
+        }
+        const timer = setTimeout(() => {
+            episode.timers.delete(timer);
             try {
-                this.inject(memberId, episode.attempts, kind);
+                this.wake(memberId);
             }
             catch {
                 this.stopTracking(memberId);
             }
         }, this.delayMs);
+        episode.timers.add(timer);
     }
     /** A turn ended cleanly (running→idle without an error): the episode is over. */
     onCleanTurnEnd(memberId) {
@@ -70,18 +66,17 @@ export class RecoveryCoordinator {
         const episode = this.episodes.get(memberId);
         if (episode === undefined)
             return;
-        this.cancelTimer(episode);
+        this.cancelTimers(episode);
         this.episodes.delete(memberId);
     }
     dispose() {
         for (const episode of this.episodes.values())
-            this.cancelTimer(episode);
+            this.cancelTimers(episode);
         this.episodes.clear();
     }
-    cancelTimer(episode) {
-        if (episode?.timer === undefined)
-            return;
-        clearTimeout(episode.timer);
-        episode.timer = undefined;
+    cancelTimers(episode) {
+        for (const timer of episode.timers)
+            clearTimeout(timer);
+        episode.timers.clear();
     }
 }

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

@@ -26,13 +26,18 @@ const operationBase = {
 const modelSelectionSchema = z.object({
     provider: z.string().min(1),
     model: z.string().min(1),
-}).strict();
+    reasoningEffort: z.string().min(1).transform(value => value).optional(),
+}).strict().transform(({ provider, model, reasoningEffort }) => ({
+    provider,
+    model,
+    ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+}));
 const memberSchema = z.object({
     memberId: memberIdSchema,
     sessionId: sessionIdSchema,
     workspaceId: workspaceIdSchema,
     handle: z.string().min(1),
-    description: z.string().min(1),
+    description: z.string(),
     presetId: z.string().min(1),
     // Ledgers written before per-Member model selection existed omit the field.
     model: modelSelectionSchema.optional(),
@@ -43,7 +48,7 @@ const channelSchema = z.object({
     channelRef: channelRefSchema,
     workspaceId: workspaceIdSchema,
     name: z.string().min(1),
-    description: z.string().min(1),
+    description: z.string(),
     createdAtSequence: z.number().int().positive(),
 }).strict();
 // Ledgers written before message occurredAt or attachments existed store bare
@@ -155,6 +160,7 @@ const taskActivitySchema = z.object({
     ...activityBase,
     kind: z.union([z.literal('accept'), z.literal('close'), z.literal('reopen')]),
     releasedClaimRefs: z.array(claimRefSchema).min(1).optional(),
+    completedClaimRefs: z.array(claimRefSchema).min(1).optional(),
 }).strict();
 const claimsReleasedActivitySchema = z.object({
     ...activityBase,
@@ -208,7 +214,7 @@ const storedAgentTeamOperationSchema = z.discriminatedUnion('kind', [
         ...operationBase,
         previousOperationId: operationIdSchema.nullable(),
         kind: z.literal('team/member-added'),
-        data: z.object({ member: memberSchema, channelRefs: z.array(channelRefSchema).min(1) }).strict(),
+        data: z.object({ member: memberSchema, channelRefs: z.array(channelRefSchema) }).strict(),
     }).strict(),
     z.object({
         ...operationBase,