@wowyuarm/dsh-agent-team 0.1.3 → 0.1.4

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

@@ -16,7 +16,7 @@ export function agentTeamHumanActor() {
 function emptyProjection() {
     return { byRequest: new Map(), byOperation: new Map(), ordered: [], channels: new Map(), members: new Map(), memberships: new Map(),
         claims: new Map(), messages: [], tasks: new Map(), threads: new Map(), attention: new Map(), directMarkers: new Map(), activityMarkers: new Map(),
-        orderedFacts: [], factsByThread: new Map(), topLevelMessages: [], mentionsByMessage: new Map(), messageCountByThread: new Map(),
+        orderedFacts: [], factsByThread: new Map(), channelRefByThread: new Map(), mentionsByMessage: new Map(), messageCountByThread: new Map(),
         attentionByThread: new Map() };
 }
 /** Exhaustiveness guard for the closed operation union: adding a kind must update every dispatch. */
@@ -282,12 +282,14 @@ export class AgentTeamLedger {
             // Human-gated (reply path).
             const sequence = this.nextSequence();
             const base = this.operationBase(request, sequence);
-            const taskRef = this.ref('task');
+            const asTask = request.asTask !== false;
             const threadRef = this.ref('thread');
-            const task = Object.freeze({ taskRef, channelRef: channel.channelRef, threadRef, status: 'todo', resolution: 'open' });
-            const thread = Object.freeze({ threadRef, taskRef, revision: sequence });
+            const taskRef = asTask ? this.ref('task') : undefined;
+            const task = taskRef === undefined ? undefined
+                : Object.freeze({ taskRef, channelRef: channel.channelRef, threadRef, status: 'todo', resolution: 'open' });
+            const thread = Object.freeze({ threadRef, ...(taskRef === undefined ? {} : { taskRef }), revision: sequence });
             const message = Object.freeze({
-                messageRef: this.ref('message'), channelRef: channel.channelRef, threadRef, taskRef,
+                messageRef: this.ref('message'), channelRef: channel.channelRef, threadRef, ...(taskRef === undefined ? {} : { taskRef }),
                 sender: request.actor.memberId, body,
                 ...(request.resolvedAttachments === undefined ? {} : { attachments: request.resolvedAttachments }),
                 topLevel: true, sequence, occurredAt: base.occurredAt,
@@ -298,7 +300,8 @@ export class AgentTeamLedger {
             const inbox = this.messageInboxDelta(message, request.actor.memberId, recipients, started);
             const operation = Object.freeze({
                 ...base, kind: 'team/message-sent',
-                data: Object.freeze({ workspaceId: request.workspaceId, mentions: recipients, message, task, thread, inbox }),
+                data: Object.freeze({ workspaceId: request.workspaceId, mentions: recipients, message,
+                    ...(task === undefined ? {} : { task }), thread, inbox }),
             });
             await this.table.put(operation.operationId, operation);
             this.apply(operation);
@@ -314,31 +317,31 @@ export class AgentTeamLedger {
                 return this.resolved(this.replyResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const { task, thread } = this.threadForActor(actor, request.workspaceId, request.taskRef);
+            const { task, thread, channelRef } = this.threadContextForActor(actor, request.workspaceId, request);
             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);
+            this.assertMentionTargets(this.requireChannel(request.workspaceId, channelRef), recipients);
             const deferred = this.deferredThreadWrite(actor.memberId, task, thread, request.baseRevision);
             if (deferred !== undefined)
                 return this.resolved(deferred);
-            if (task.resolution === 'closed')
+            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));
             if (unfollowedAgents.length > 0 && actor.kind === 'member') {
-                return this.resolved(this.memberNotFollowing(request.workspaceId, task.channelRef, unfollowedAgents, task, thread));
+                return this.resolved(this.memberNotFollowing(request.workspaceId, channelRef, unfollowedAgents, task, thread));
             }
             if (unfollowedAgents.length > 0 && request.confirmationToken === undefined) {
-                return this.resolved(this.issueConfirmation(request.actor, request.workspaceId, task.channelRef, body, recipients, task, thread));
+                return this.resolved(this.issueConfirmation(request.actor, request.workspaceId, channelRef, body, recipients, task, thread));
             }
             if (request.confirmationToken !== undefined) {
-                this.consumeConfirmation(request.confirmationToken, request.actor, request.workspaceId, task.channelRef, task, thread, body, recipients);
+                this.consumeConfirmation(request.confirmationToken, request.actor, request.workspaceId, channelRef, task, thread, body, recipients);
             }
             const sequence = this.nextSequence();
             const base = this.operationBase(request, sequence);
             const message = Object.freeze({
-                messageRef: this.ref('message'), channelRef: task.channelRef, threadRef: task.threadRef,
-                taskRef: task.taskRef, sender: request.actor.memberId, body,
+                messageRef: this.ref('message'), channelRef, threadRef: thread.threadRef,
+                ...(task === undefined ? {} : { taskRef: task.taskRef }), sender: request.actor.memberId, body,
                 ...(request.resolvedAttachments === undefined ? {} : { attachments: request.resolvedAttachments }),
                 topLevel: false, sequence, occurredAt: base.occurredAt,
             });
@@ -348,13 +351,45 @@ export class AgentTeamLedger {
             const operation = Object.freeze({
                 ...base, kind: 'team/thread-replied',
                 data: Object.freeze({ workspaceId: request.workspaceId, baseRevision: request.baseRevision,
-                    mentions: recipients, message, task, thread: nextThread, inbox }),
+                    mentions: recipients, message, ...(task === undefined ? {} : { task }), thread: nextThread, inbox }),
             });
             await this.table.put(operation.operationId, operation);
             this.apply(operation);
             return this.committed(this.replyResult(operation));
         });
     }
+    promoteThread(request) {
+        return this.enqueue(async () => {
+            const existing = this.state.byRequest.get(request.requestId);
+            if (existing !== undefined) {
+                this.assertSamePromotion(existing, request);
+                return this.resolved(this.promotionResult(existing));
+            }
+            this.assertHumanActor(request.actor);
+            const { task: existingTask, thread, channelRef } = this.threadContextForActor(request.actor, request.workspaceId, request);
+            if (existingTask !== undefined)
+                throw new Error(`Thread '${thread.threadRef}' already has Task '${existingTask.taskRef}'`);
+            const deferred = this.deferredThreadWrite(request.actor.memberId, undefined, thread, request.baseRevision);
+            if (deferred !== undefined)
+                return this.resolved(deferred);
+            const sequence = this.nextSequence();
+            const base = this.operationBase(request, sequence);
+            const taskRef = this.ref('task');
+            const task = Object.freeze({ taskRef, channelRef, threadRef: thread.threadRef, status: 'todo', resolution: 'open' });
+            const nextThread = Object.freeze({ threadRef: thread.threadRef, taskRef, revision: sequence });
+            const activity = Object.freeze({ activityRef: this.ref('activity'), kind: 'promote',
+                taskRef, threadRef: thread.threadRef, actor: request.actor.memberId, sequence });
+            const inbox = this.promoteThreadInbox(activity, thread.threadRef);
+            const operation = Object.freeze({
+                ...base, kind: 'team/thread-promoted',
+                data: Object.freeze({ workspaceId: request.workspaceId, baseRevision: request.baseRevision,
+                    activity, task, thread: nextThread, inbox }),
+            });
+            await this.table.put(operation.operationId, operation);
+            this.apply(operation);
+            return this.committed(this.promotionResult(operation));
+        });
+    }
     changeClaim(request) {
         return this.enqueue(async () => {
             const existing = this.state.byRequest.get(request.requestId);
@@ -526,10 +561,10 @@ export class AgentTeamLedger {
                 return this.resolved(this.attentionResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const { task, thread } = this.threadForActor(actor, request.workspaceId, request.taskRef);
+            const { task, thread } = this.threadContextForActor(actor, request.workspaceId, request);
             const current = this.attentionFor(actor.memberId, thread.threadRef);
             if (request.action === 'follow') {
-                if (task.resolution === 'closed')
+                if (task?.resolution === 'closed')
                     throw new Error(`Task '${task.taskRef}' is closed; reopen it before following`);
                 if (current !== undefined)
                     throw new Error(`Member is already following Thread '${thread.threadRef}'`);
@@ -537,7 +572,7 @@ export class AgentTeamLedger {
                 const operation = Object.freeze({
                     ...this.operationBase(request, this.nextSequence()), kind: 'team/thread-attention-changed',
                     data: Object.freeze({ workspaceId: request.workspaceId, action: 'follow', memberId: actor.memberId,
-                        task, thread, inbox: this.inboxDelta([attention]) }),
+                        ...(task === undefined ? {} : { task }), thread, inbox: this.inboxDelta([attention]) }),
                 });
                 await this.table.put(operation.operationId, operation);
                 this.apply(operation);
@@ -545,12 +580,12 @@ export class AgentTeamLedger {
             }
             if (current === undefined)
                 throw new Error(`Member is already unfollowed from Thread '${thread.threadRef}'`);
-            if (this.hasActiveClaim(actor.memberId, task.taskRef))
+            if (task !== undefined && this.hasActiveClaim(actor.memberId, task.taskRef))
                 throw new Error('Member cannot unfollow while owning an active Claim');
             const operation = Object.freeze({
                 ...this.operationBase(request, this.nextSequence()), kind: 'team/thread-attention-changed',
                 data: Object.freeze({ workspaceId: request.workspaceId, action: 'unfollow', memberId: actor.memberId,
-                    task, thread, inbox: this.inboxDelta([], [{ memberId: actor.memberId, threadRef: thread.threadRef }], [], this.directMarkersFor(actor.memberId, thread.threadRef)) }),
+                    ...(task === undefined ? {} : { task }), thread, inbox: this.inboxDelta([], [{ memberId: actor.memberId, threadRef: thread.threadRef }], [], this.directMarkersFor(actor.memberId, thread.threadRef)) }),
             });
             await this.table.put(operation.operationId, operation);
             this.apply(operation);
@@ -559,11 +594,9 @@ export class AgentTeamLedger {
     }
     attentionStatus(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const { task, thread } = this.threadForActor(authorized, request.workspaceId, request.taskRef);
+        const { task, thread } = this.threadContextForActor(authorized, request.workspaceId, request);
         const attention = this.attentionFor(authorized.memberId, thread.threadRef);
-        return attention === undefined
-            ? Object.freeze({ task, thread })
-            : Object.freeze({ task, thread, attention });
+        return Object.freeze({ ...(task === undefined ? {} : { task }), thread, ...(attention === undefined ? {} : { attention }) });
     }
     inbox(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
@@ -571,22 +604,22 @@ export class AgentTeamLedger {
         if (!Number.isInteger(limit) || limit < 1 || limit > 100)
             throw new Error('inbox limit must be an integer between 1 and 100');
         const items = [];
-        for (const task of this.state.tasks.values()) {
-            if (this.state.channels.get(task.channelRef)?.workspaceId !== request.workspaceId)
+        for (const thread of this.state.threads.values()) {
+            const channelRef = this.channelRefForThread(thread.threadRef);
+            if (channelRef === undefined)
                 continue;
-            if (authorized.kind === 'member' && !this.isChannelMember(task.channelRef, authorized.memberId))
+            if (this.state.channels.get(channelRef)?.workspaceId !== request.workspaceId)
+                continue;
+            if (authorized.kind === 'member' && !this.isChannelMember(channelRef, authorized.memberId))
                 continue;
-            const thread = this.requireThread(task.threadRef);
             const unread = this.unreadFor(authorized.memberId, thread.threadRef);
             if (unread.length === 0)
                 continue;
+            const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
             const directCount = unread.filter(item => item.direct).length;
             const attention = this.attentionFor(authorized.memberId, thread.threadRef);
-            items.push(attention === undefined
-                ? Object.freeze({ channelRef: task.channelRef, task, thread, unreadCount: unread.length, directCount,
-                    newestSequence: unread.at(-1).fact.sequence })
-                : Object.freeze({ channelRef: task.channelRef, task, thread, unreadCount: unread.length, directCount,
-                    newestSequence: unread.at(-1).fact.sequence, attention }));
+            items.push(Object.freeze({ channelRef, ...(task === undefined ? {} : { task }), thread, unreadCount: unread.length, directCount,
+                newestSequence: unread.at(-1).fact.sequence, ...(attention === undefined ? {} : { attention }) }));
         }
         items.sort((left, right) => right.directCount - left.directCount || right.newestSequence - left.newestSequence || left.thread.threadRef.localeCompare(right.thread.threadRef));
         const selected = items.slice(0, limit);
@@ -611,10 +644,11 @@ export class AgentTeamLedger {
                 return this.resolved(this.threadReadResult(existing));
             }
             const actor = this.assertActorForWorkspace(request.actor, request.workspaceId);
-            const prepared = this.prepareRead(actor.memberId, request.workspaceId, request.taskRef);
+            const prepared = this.prepareRead(actor.memberId, request.workspaceId, request);
             const operation = Object.freeze({
                 ...this.operationBase(request, this.nextSequence()), kind: 'team/thread-read',
-                data: Object.freeze({ workspaceId: request.workspaceId, memberId: actor.memberId, task: prepared.task,
+                data: Object.freeze({ workspaceId: request.workspaceId, memberId: actor.memberId,
+                    ...(prepared.task === undefined ? {} : { task: prepared.task }),
                     thread: prepared.thread, claims: prepared.claims, anchor: prepared.anchor, anchorMentions: prepared.anchorMentions,
                     facts: prepared.facts,
                     readThroughSequence: prepared.readThroughSequence, remainingUnreadCount: prepared.remainingUnreadCount,
@@ -627,11 +661,11 @@ export class AgentTeamLedger {
     }
     threadObservations(actor, request) {
         this.assertHumanActor(actor);
-        const task = this.requireTask(request.workspaceId, request.taskRef);
+        const { task, thread } = this.threadContextForActor(actor, request.workspaceId, request);
         const limit = request.limit ?? 50;
         if (!Number.isInteger(limit) || limit < 1 || limit > 100)
             throw new Error('observation limit must be an integer between 1 and 100');
-        const threadRef = task.threadRef;
+        const threadRef = thread.threadRef;
         const current = new Map();
         const observations = [];
         for (const operation of this.state.ordered) {
@@ -643,7 +677,7 @@ export class AgentTeamLedger {
                     continue;
                 if (!current.delete(removed.memberId))
                     continue;
-                observations.push(Object.freeze({ sequence: operation.sequence, threadRef, taskRef: task.taskRef,
+                observations.push(Object.freeze({ sequence: operation.sequence, threadRef, ...(task === undefined ? {} : { taskRef: task.taskRef }),
                     memberId: removed.memberId, action: 'unfollow' }));
             }
             for (const next of delta.attention.set) {
@@ -654,7 +688,7 @@ export class AgentTeamLedger {
                 // Task creation establishes initial Attention; reads only advance its watermark.
                 if (operation.kind === 'team/message-sent' || (prior !== undefined && prior.startSequence === next.startSequence))
                     continue;
-                observations.push(Object.freeze({ sequence: operation.sequence, threadRef, taskRef: task.taskRef,
+                observations.push(Object.freeze({ sequence: operation.sequence, threadRef, ...(task === undefined ? {} : { taskRef: task.taskRef }),
                     memberId: next.memberId, action: 'follow' }));
             }
         }
@@ -677,7 +711,7 @@ export class AgentTeamLedger {
     }
     threadHistory(actor, request) {
         const authorized = this.assertActorForWorkspace(actor, request.workspaceId);
-        const { task, thread } = this.threadForActor(authorized, request.workspaceId, request.taskRef);
+        const { task, thread } = this.threadContextForActor(authorized, request.workspaceId, request);
         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');
@@ -686,9 +720,9 @@ export class AgentTeamLedger {
             throw new Error('beforeSequence must be a positive integer');
         const all = this.threadFacts(thread.threadRef).filter(fact => fact.sequence < before);
         const facts = all.slice(-limit);
-        const anchor = this.threadAnchor(task);
-        return Object.freeze({ task, thread, anchor, anchorMentions: this.state.mentionsByMessage.get(anchor.messageRef) ?? [],
-            claims: this.claimsForTask(task.taskRef), facts: Object.freeze(facts),
+        const anchor = this.threadAnchor(thread.threadRef);
+        return Object.freeze({ ...(task === undefined ? {} : { task }), thread, anchor, anchorMentions: this.state.mentionsByMessage.get(anchor.messageRef) ?? [],
+            claims: task === undefined ? Object.freeze([]) : this.claimsForTask(task.taskRef), facts: Object.freeze(facts),
             cursor: facts.length === 0 ? before : facts[0].sequence, hasMore: all.length > facts.length });
     }
     listClaims(actor, request) {
@@ -736,22 +770,27 @@ export class AgentTeamLedger {
         }
         if (request.threadRef !== undefined) {
             const thread = this.requireThread(request.threadRef);
-            const task = this.requireTask(request.workspaceId, thread.taskRef);
-            if (request.channelRef !== undefined && task.channelRef !== request.channelRef)
+            const channelRef = this.channelRefForThread(thread.threadRef);
+            if (channelRef === undefined)
+                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}'`);
+            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(task.channelRef, memberId))
-                throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${task.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
             && (memberId === undefined || this.isChannelMember(channel.channelRef, memberId)));
         const channelRefs = new Set(channels.map(channel => channel.channelRef));
         const allFacts = this.state.orderedFacts.filter(fact => {
-            const task = fact.kind === 'message' ? this.state.tasks.get(fact.message.taskRef) : this.state.tasks.get(fact.activity.taskRef);
-            if (task === undefined || !channelRefs.has(task.channelRef))
+            const threadRef = fact.kind === 'message' ? fact.message.threadRef : fact.activity.threadRef;
+            const channelRef = this.channelRefForThread(threadRef);
+            if (channelRef === undefined || !channelRefs.has(channelRef))
                 return false;
-            if (request.channelRef !== undefined && task.channelRef !== request.channelRef)
+            if (request.channelRef !== undefined && channelRef !== request.channelRef)
                 return false;
-            if (request.threadRef !== undefined && task.threadRef !== request.threadRef)
+            if (request.threadRef !== undefined && threadRef !== request.threadRef)
                 return false;
             if (request.topLevelOnly && (fact.kind !== 'message' || !fact.message.topLevel))
                 return false;
@@ -766,9 +805,9 @@ export class AgentTeamLedger {
         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);
             const thread = this.requireThread(message.threadRef);
-            return Object.freeze({ message, mentions: fact.mentions, task, thread, taskNumber: taskNumbers.get(task.taskRef) ?? 0,
+            const task = thread.taskRef === undefined ? undefined : this.state.tasks.get(thread.taskRef);
+            return Object.freeze({ message, mentions: fact.mentions, ...(task === undefined ? {} : { task, taskNumber: taskNumbers.get(task.taskRef) ?? 0 }), thread,
                 messageCount: this.state.messageCountByThread.get(thread.threadRef) ?? 0 });
         });
         const initialization = this.initialization();
@@ -778,7 +817,12 @@ export class AgentTeamLedger {
             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 })))),
             tasks: Object.freeze(visibleTasks),
-            threads: Object.freeze([...this.state.threads.values()].filter(thread => visibleTasks.some(task => task.taskRef === thread.taskRef))),
+            threads: Object.freeze([...this.state.threads.values()].filter(thread => {
+                const channelRef = this.channelRefForThread(thread.threadRef);
+                return channelRef !== undefined && channelRefs.has(channelRef)
+                    && (request.channelRef === undefined || channelRef === request.channelRef)
+                    && (request.threadRef === undefined || thread.threadRef === request.threadRef);
+            })),
             taskNumbers: Object.freeze(visibleTasks.map(task => Object.freeze({ taskRef: task.taskRef, taskNumber: taskNumbers.get(task.taskRef) ?? 0 }))),
             items: Object.freeze(items),
             claims: this.claimsForVisibleTasks(visibleTasks),
@@ -839,6 +883,8 @@ export class AgentTeamLedger {
             case 'team/message-sent':
             case 'team/thread-replied':
                 return [{ kind: 'channel', channelRef: operation.data.message.channelRef }, { kind: 'thread', threadRef: operation.data.message.threadRef }];
+            case 'team/thread-promoted':
+                return [{ kind: 'channel', channelRef: operation.data.task.channelRef }, { kind: 'thread', threadRef: operation.data.thread.threadRef }];
             case 'team/claim-created':
             case 'team/claim-done':
             case 'team/claim-released':
@@ -885,6 +931,8 @@ export class AgentTeamLedger {
             case 'team/message-sent':
             case 'team/thread-replied':
                 return [operation.data.message.threadRef];
+            case 'team/thread-promoted':
+                return [operation.data.activity.threadRef];
             case 'team/claim-created':
             case 'team/claim-done':
             case 'team/claim-released':
@@ -1051,7 +1099,7 @@ export class AgentTeamLedger {
             if (channel === undefined || member === undefined || operation.data.workspaceId !== channel.workspaceId
                 || member.workspaceId !== channel.workspaceId || !projection.memberships.get(channel.channelRef)?.has(member.memberId))
                 throw new Error('invalid Channel membership removal');
-            const threadRefs = new Set([...projection.tasks.values()].filter(task => task.channelRef === channel.channelRef).map(task => task.threadRef));
+            const threadRefs = new Set([...projection.threads.keys()].filter(threadRef => this.channelRefForThreadFrom(projection, threadRef) === channel.channelRef));
             this.validateReleaseCleanup(operation.data, projection, member.memberId, threadRefs, operation.sequence, refs);
             return;
         }
@@ -1060,7 +1108,7 @@ export class AgentTeamLedger {
             const prior = projection.members.get(operation.data.member.memberId);
             if (prior === undefined || prior.state === 'inactive' || operation.data.member.state !== 'inactive' || !this.sameMemberIdentity(prior, operation.data.member))
                 throw new Error('invalid Member removal');
-            const threadRefs = new Set([...projection.tasks.values()].map(task => task.threadRef));
+            const threadRefs = new Set(projection.threads.keys());
             this.validateReleaseCleanup(operation.data, projection, prior.memberId, threadRefs, operation.sequence, refs);
             return;
         }
@@ -1068,15 +1116,17 @@ export class AgentTeamLedger {
             const actor = operation.actor.kind === 'member' ? assertMember() : (assertHuman(), undefined);
             if (operation.data.memberId !== operation.actor.memberId)
                 throw new Error('Attention operation has wrong actor');
-            const task = projection.tasks.get(operation.data.task.taskRef);
             const thread = projection.threads.get(operation.data.thread.threadRef);
-            if (task === undefined || thread === undefined || !this.sameTask(task, operation.data.task)
-                || !this.sameThread(thread, operation.data.thread)
-                || (actor !== undefined && !projection.memberships.get(task.channelRef)?.has(actor.memberId)))
+            const task = operation.data.task;
+            const currentTask = thread?.taskRef === undefined ? undefined : projection.tasks.get(thread.taskRef);
+            const channelRef = thread === undefined ? undefined : this.channelRefForThreadFrom(projection, thread.threadRef);
+            if (thread === undefined || channelRef === undefined || !this.sameThread(thread, operation.data.thread)
+                || (task === undefined ? currentTask !== undefined : currentTask === undefined || !this.sameTask(currentTask, task) || thread.taskRef !== task.taskRef)
+                || (actor !== undefined && !projection.memberships.get(channelRef)?.has(actor.memberId)))
                 throw new Error('invalid Attention operation');
             const current = this.attentionForFrom(projection, operation.data.memberId, thread.threadRef);
-            if ((operation.data.action === 'follow' && (task.resolution === 'closed' || current !== undefined))
-                || (operation.data.action === 'unfollow' && (current === undefined || this.hasActiveClaimFrom(projection, operation.data.memberId, task.taskRef)))) {
+            if ((operation.data.action === 'follow' && (task?.resolution === 'closed' || current !== undefined))
+                || (operation.data.action === 'unfollow' && (current === undefined || (task !== undefined && this.hasActiveClaimFrom(projection, operation.data.memberId, task.taskRef))))) {
                 throw new Error('invalid Attention transition');
             }
             const expected = operation.data.action === 'follow'
@@ -1094,9 +1144,12 @@ export class AgentTeamLedger {
                 assertHuman();
             if (operation.data.memberId !== operation.actor.memberId)
                 throw new Error('Thread read has wrong actor');
-            const expected = this.prepareReadFrom(projection, operation.data.memberId, operation.data.workspaceId, operation.data.task.taskRef);
+            const expected = this.prepareReadFrom(projection, operation.data.memberId, operation.data.workspaceId, {
+                threadRef: operation.data.thread.threadRef,
+                ...(operation.data.task === undefined ? {} : { taskRef: operation.data.task.taskRef }),
+            });
             const expectedData = Object.freeze({ workspaceId: operation.data.workspaceId, memberId: operation.data.memberId,
-                task: expected.task, thread: expected.thread, claims: expected.claims, anchor: expected.anchor,
+                ...(expected.task === undefined ? {} : { task: expected.task }), thread: expected.thread, claims: expected.claims, anchor: expected.anchor,
                 anchorMentions: expected.anchorMentions, facts: expected.facts,
                 readThroughSequence: expected.readThroughSequence, remainingUnreadCount: expected.remainingUnreadCount,
                 ...(expected.attention === undefined ? {} : { attention: expected.attention }), inbox: expected.inbox });
@@ -1105,27 +1158,56 @@ export class AgentTeamLedger {
             this.validateInboxDelta(operation.data.inbox, projection, refs);
             return;
         }
+        if (operation.kind === 'team/thread-promoted') {
+            assertHuman();
+            const { activity, task, thread } = operation.data;
+            const priorThread = projection.threads.get(thread.threadRef);
+            const channelRef = priorThread === undefined ? undefined : this.channelRefForThreadFrom(projection, thread.threadRef);
+            if (priorThread === undefined || priorThread.taskRef !== undefined || projection.tasks.has(task.taskRef)
+                || channelRef === undefined || task.channelRef !== channelRef
+                || projection.channels.get(channelRef)?.workspaceId !== operation.data.workspaceId
+                || operation.data.baseRevision !== priorThread.revision
+                || task.status !== 'todo' || task.resolution !== 'open'
+                || thread.revision !== operation.sequence || task.threadRef !== thread.threadRef || thread.taskRef !== task.taskRef
+                || !this.sameThread(thread, { ...priorThread, taskRef: task.taskRef, revision: operation.sequence })
+                || activity.kind !== 'promote' || activity.sequence !== operation.sequence || activity.actor !== operation.actor.memberId
+                || activity.taskRef !== task.taskRef || activity.threadRef !== thread.threadRef)
+                throw new Error('invalid Thread promotion');
+            this.addRef(refs, task.taskRef);
+            this.addRef(refs, activity.activityRef);
+            const expectedInbox = this.promoteThreadInboxFrom(projection, activity, thread.threadRef);
+            if (!isDeepStrictEqual(operation.data.inbox, expectedInbox))
+                throw new Error('invalid Promotion inbox projection');
+            this.validateInboxDelta(operation.data.inbox, projection, refs, [], [], [activity]);
+            return;
+        }
         if (operation.kind === 'team/message-sent' || operation.kind === 'team/thread-replied') {
             const actor = operation.actor.kind === 'member' ? assertMember() : (assertHuman(), undefined);
             const { message, task, thread } = operation.data;
             const channel = projection.channels.get(message.channelRef);
             if (channel === undefined || channel.workspaceId !== operation.data.workspaceId || message.sender !== operation.actor.memberId
-                || message.sequence !== operation.sequence || thread.revision !== operation.sequence || message.taskRef !== task.taskRef
-                || message.threadRef !== thread.threadRef || task.threadRef !== thread.threadRef || task.channelRef !== channel.channelRef
+                || message.sequence !== operation.sequence || thread.revision !== operation.sequence
+                || message.threadRef !== thread.threadRef
+                || (task === undefined ? message.taskRef !== undefined || thread.taskRef !== undefined
+                    : message.taskRef !== task.taskRef || thread.taskRef !== task.taskRef || task.threadRef !== thread.threadRef || task.channelRef !== channel.channelRef)
                 || (actor !== undefined && !projection.memberships.get(channel.channelRef)?.has(actor.memberId)))
                 throw new Error('invalid Message operation');
             if (operation.kind === 'team/message-sent') {
-                if (!message.topLevel || projection.tasks.has(task.taskRef) || projection.threads.has(thread.threadRef))
+                if (!message.topLevel || projection.threads.has(thread.threadRef) || (task !== undefined && projection.tasks.has(task.taskRef))) {
                     throw new Error('invalid top-level Message operation');
-                this.addRef(refs, task.taskRef);
+                }
                 this.addRef(refs, thread.threadRef);
+                if (task !== undefined)
+                    this.addRef(refs, task.taskRef);
             }
             else {
-                const priorTask = projection.tasks.get(task.taskRef);
                 const priorThread = projection.threads.get(thread.threadRef);
-                if (message.topLevel || priorTask === undefined || priorThread === undefined || !this.sameTask(priorTask, task)
-                    || priorThread.taskRef !== thread.taskRef || operation.data.baseRevision !== priorThread.revision)
+                const priorTask = task === undefined ? undefined : projection.tasks.get(task.taskRef);
+                if (message.topLevel || priorThread === undefined || operation.data.baseRevision !== priorThread.revision
+                    || priorThread.taskRef !== thread.taskRef
+                    || (task === undefined ? priorTask !== undefined : priorTask === undefined || !this.sameTask(priorTask, task))) {
                     throw new Error('invalid Thread reply');
+                }
             }
             this.addRef(refs, message.messageRef);
             this.validateMentions(operation.data.mentions, message, projection);
@@ -1444,13 +1526,23 @@ export class AgentTeamLedger {
             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);
+            target.threads.set(operation.data.thread.threadRef, operation.data.thread);
+            this.applyInboxDelta(target, operation.data.inbox);
+            return;
+        }
         if (operation.kind === 'team/message-sent' || operation.kind === 'team/thread-replied') {
             const { message, mentions } = operation.data;
             target.messages.push(message);
             target.mentionsByMessage.set(message.messageRef, Object.freeze([...mentions]));
             this.appendMessageFact(target, message, mentions);
-            target.tasks.set(operation.data.task.taskRef, operation.data.task);
+            if (operation.data.task !== undefined)
+                target.tasks.set(operation.data.task.taskRef, operation.data.task);
             target.threads.set(operation.data.thread.threadRef, operation.data.thread);
+            if (message.topLevel)
+                target.channelRefByThread.set(message.threadRef, message.channelRef);
             this.applyInboxDelta(target, operation.data.inbox);
             return;
         }
@@ -1484,8 +1576,6 @@ export class AgentTeamLedger {
         const facts = target.factsByThread.get(message.threadRef) ?? [];
         facts.push(fact);
         target.factsByThread.set(message.threadRef, facts);
-        if (message.topLevel)
-            target.topLevelMessages.push(message);
         target.messageCountByThread.set(message.threadRef, (target.messageCountByThread.get(message.threadRef) ?? 0) + 1);
     }
     appendActivityFact(target, activity) {
@@ -1520,26 +1610,19 @@ export class AgentTeamLedger {
         for (const marker of delta.activityMarkers.added)
             target.activityMarkers.set(this.activityMarkerKey(marker), marker);
     }
-    prepareRead(memberId, workspaceId, taskRef) {
-        return this.prepareReadFrom(this.state, memberId, workspaceId, taskRef);
+    prepareRead(memberId, workspaceId, request) {
+        return this.prepareReadFrom(this.state, memberId, workspaceId, request);
     }
     /** Derive the only legal durable result of one Thread read from a prior projection. */
-    prepareReadFrom(projection, memberId, workspaceId, taskRef) {
-        const task = projection.tasks.get(taskRef);
-        if (task === undefined)
-            throw new Error(`unknown Task ref '${taskRef}'${this.unknownRefHint(taskRef, 'task', 'Task')}`);
-        if (projection.channels.get(task.channelRef)?.workspaceId !== workspaceId)
-            throw new Error(`Task '${taskRef}' does not belong to Workspace '${workspaceId}'`);
-        const thread = projection.threads.get(task.threadRef);
-        if (thread === undefined)
-            throw new Error(`unknown Thread ref '${task.threadRef}'`);
+    prepareReadFrom(projection, memberId, workspaceId, request) {
+        const { task, thread, channelRef } = this.threadContextFrom(projection, workspaceId, request);
         if (memberId !== AGENT_TEAM_HUMAN_MEMBER_ID) {
             const member = projection.members.get(memberId);
-            if (member === undefined || !projection.memberships.get(task.channelRef)?.has(member.memberId)) {
-                throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${task.channelRef}'`);
+            if (member === undefined || !projection.memberships.get(channelRef)?.has(member.memberId)) {
+                throw new Error(`Agent Member '${memberId}' is not authorized for Channel '${channelRef}'`);
             }
         }
-        const anchor = this.threadAnchorFrom(projection, task);
+        const anchor = this.threadAnchorFrom(projection, thread.threadRef);
         const attention = this.attentionForFrom(projection, memberId, thread.threadRef);
         const unread = this.unreadForFrom(projection, memberId, thread.threadRef);
         const unreadFacts = unread.slice(0, 20);
@@ -1580,7 +1663,7 @@ export class AgentTeamLedger {
         };
         this.applyInboxDelta(nextProjection, inbox);
         const remainingUnreadCount = this.unreadForFrom(nextProjection, memberId, thread.threadRef).length;
-        return Object.freeze({ task, thread, claims: this.claimsForTaskFrom(projection, task.taskRef), anchor,
+        return Object.freeze({ ...(task === undefined ? {} : { task }), thread, claims: task === undefined ? Object.freeze([]) : this.claimsForTaskFrom(projection, task.taskRef), anchor,
             anchorMentions: projection.mentionsByMessage.get(anchor.messageRef) ?? [],
             facts: Object.freeze(combined),
             readThroughSequence, remainingUnreadCount, ...(attention === undefined ? {} : { attention: nextAttention[0] ?? attention }),
@@ -1670,6 +1753,17 @@ export class AgentTeamLedger {
             activityRef: activity.activityRef, sequence: activity.sequence }));
         return this.inboxDelta([], [], [], [], markers);
     }
+    /** Promotion wakes every current follower; the Human actor never follows, so no recipient filter is needed. */
+    promoteThreadInbox(activity, threadRef) {
+        return this.promoteThreadInboxFrom(this.state, activity, threadRef);
+    }
+    promoteThreadInboxFrom(projection, activity, threadRef) {
+        const markers = [...projection.attention.values()]
+            .filter(attention => attention.threadRef === threadRef && attention.memberId !== activity.actor)
+            .map(attention => Object.freeze({ memberId: attention.memberId, threadRef,
+            activityRef: activity.activityRef, sequence: activity.sequence }));
+        return this.inboxDelta([], [], [], [], markers);
+    }
     removeMemberThreadInbox(memberId, threadRefs) {
         const removed = [...this.state.attention.values()].filter(attention => attention.memberId === memberId && threadRefs.has(attention.threadRef))
             .map(attention => Object.freeze({ memberId, threadRef: attention.threadRef }));
@@ -1762,11 +1856,11 @@ export class AgentTeamLedger {
             ...(task === undefined ? {} : { taskRef: task.taskRef }), ...(thread === undefined ? {} : { threadRef: thread.threadRef, revision: thread.revision }) });
     }
     unreadRequired(task, thread, unread) {
-        return Object.freeze({ kind: 'unread_required', taskRef: task.taskRef, threadRef: thread.threadRef,
+        return Object.freeze({ kind: 'unread_required', ...(task === undefined ? {} : { taskRef: task.taskRef }), threadRef: thread.threadRef,
             revision: thread.revision, unreadCount: unread.length, directCount: unread.filter(item => item.direct).length });
     }
     staleRevision(task, thread, expectedRevision) {
-        return Object.freeze({ kind: 'stale_revision', taskRef: task.taskRef, threadRef: thread.threadRef,
+        return Object.freeze({ kind: 'stale_revision', ...(task === undefined ? {} : { taskRef: task.taskRef }), threadRef: thread.threadRef,
             expectedRevision, revision: thread.revision });
     }
     releaseSummaries(claims, actor, sequence) {
@@ -1819,16 +1913,16 @@ export class AgentTeamLedger {
     /** 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,
+            ...(operation.data.task === undefined ? {} : { 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);
+    threadAnchor(threadRef) {
+        return this.threadAnchorFrom(this.state, threadRef);
     }
-    threadAnchorFrom(projection, task) {
-        const anchor = projection.messages.find(message => message.taskRef === task.taskRef && message.topLevel);
+    threadAnchorFrom(projection, threadRef) {
+        const anchor = projection.messages.find(message => message.threadRef === threadRef && message.topLevel);
         if (anchor === undefined)
-            throw new Error(`Task '${task.taskRef}' has no anchor Message`);
+            throw new Error(`Thread '${threadRef}' has no anchor Message`);
         return anchor;
     }
     threadFactKey(fact) {
@@ -1843,12 +1937,15 @@ export class AgentTeamLedger {
     taskNumbers(workspaceId) {
         const numbers = new Map();
         const next = new Map();
-        for (const message of this.state.topLevelMessages) {
-            if (this.state.channels.get(message.channelRef)?.workspaceId !== workspaceId)
+        for (const operation of this.state.ordered) {
+            const task = operation.kind === 'team/message-sent' || operation.kind === 'team/thread-promoted' ? operation.data.task : undefined;
+            if (task === undefined)
+                continue;
+            if (this.state.channels.get(task.channelRef)?.workspaceId !== workspaceId)
                 continue;
-            const ordinal = (next.get(message.channelRef) ?? 0) + 1;
-            next.set(message.channelRef, ordinal);
-            numbers.set(message.taskRef, ordinal);
+            const ordinal = (next.get(task.channelRef) ?? 0) + 1;
+            next.set(task.channelRef, ordinal);
+            numbers.set(task.taskRef, ordinal);
         }
         return numbers;
     }
@@ -1932,6 +2029,53 @@ export class AgentTeamLedger {
             throw new Error(`unknown Thread ref '${threadRef}'${this.unknownRefHint(threadRef, 'thread', 'Thread')}`);
         return thread;
     }
+    channelRefForThread(threadRef) {
+        return this.channelRefForThreadFrom(this.state, threadRef);
+    }
+    channelRefForThreadFrom(projection, threadRef) {
+        return projection.channelRefByThread.get(threadRef);
+    }
+    threadContextForActor(actor, workspaceId, request) {
+        const resolved = this.threadContextFrom(this.state, workspaceId, request);
+        if (actor.kind === 'member')
+            this.requireMemberChannel(this.requireMember(actor.memberId), resolved.channelRef);
+        return resolved;
+    }
+    threadContextFrom(projection, workspaceId, request) {
+        if (request.threadRef === undefined && request.taskRef === undefined)
+            throw new Error('Thread addressing requires threadRef or taskRef');
+        let thread;
+        let task;
+        if (request.threadRef !== undefined) {
+            thread = projection.threads.get(request.threadRef);
+            if (thread === undefined)
+                throw new Error(`unknown Thread ref '${request.threadRef}'${this.unknownRefHint(request.threadRef, 'thread', 'Thread')}`);
+            task = thread.taskRef === undefined ? undefined : projection.tasks.get(thread.taskRef);
+        }
+        if (request.taskRef !== undefined) {
+            const byTask = projection.tasks.get(request.taskRef);
+            if (byTask === undefined)
+                throw new Error(`unknown Task ref '${request.taskRef}'${this.unknownRefHint(request.taskRef, 'task', 'Task')}`);
+            if (task !== undefined && task.taskRef !== byTask.taskRef)
+                throw new Error(`Task '${request.taskRef}' does not belong to Thread '${request.threadRef}'`);
+            if (thread !== undefined && byTask.threadRef !== thread.threadRef)
+                throw new Error(`Task '${request.taskRef}' does not belong to Thread '${thread.threadRef}'`);
+            task = byTask;
+            thread = projection.threads.get(byTask.threadRef);
+            if (thread === undefined)
+                throw new Error(`unknown Thread ref '${byTask.threadRef}'`);
+        }
+        if (thread === undefined)
+            throw new Error('unknown Thread');
+        const channelRef = this.channelRefForThreadFrom(projection, thread.threadRef);
+        if (channelRef === undefined)
+            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}'`);
+        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 };
+    }
     requireChannel(workspaceId, channelRef) {
         const channel = this.state.channels.get(channelRef);
         if (channel === undefined)
@@ -2059,16 +2203,28 @@ export class AgentTeamLedger {
         if (operation.kind !== 'team/message-sent' || !this.sameActor(operation.actor, request.actor)
             || operation.data.workspaceId !== request.workspaceId || operation.data.message.channelRef !== request.channelRef
             || operation.data.message.body !== request.body.trim() || !this.sameList(operation.data.mentions, recipients)
-            || !this.sameList(operation.data.message.attachments?.map(attachment => attachment.attachmentId) ?? [], request.attachments ?? []))
+            || !this.sameList(operation.data.message.attachments?.map(attachment => attachment.attachmentId) ?? [], request.attachments ?? [])
+            || (request.asTask !== false) !== (operation.data.task !== undefined))
             this.throwRequestCollision(request.requestId);
     }
     assertSameReply(operation, request, recipients) {
         if (operation.kind !== 'team/thread-replied' || !this.sameActor(operation.actor, request.actor)
-            || operation.data.workspaceId !== request.workspaceId || operation.data.message.taskRef !== request.taskRef
+            || operation.data.workspaceId !== request.workspaceId
+            || (request.threadRef !== undefined && operation.data.thread.threadRef !== request.threadRef)
+            || (request.taskRef !== undefined && operation.data.task?.taskRef !== request.taskRef)
+            || (request.threadRef === undefined && request.taskRef === undefined)
             || operation.data.message.body !== request.body.trim() || operation.data.baseRevision !== request.baseRevision
             || !this.sameList(operation.data.mentions, recipients))
             this.throwRequestCollision(request.requestId);
     }
+    assertSamePromotion(operation, request) {
+        if (operation.kind !== 'team/thread-promoted' || !this.sameActor(operation.actor, request.actor)
+            || operation.data.workspaceId !== request.workspaceId
+            || operation.data.thread.threadRef !== request.threadRef
+            || operation.data.baseRevision !== request.baseRevision) {
+            this.throwRequestCollision(request.requestId);
+        }
+    }
     assertSameClaim(operation, request) {
         const kind = request.action === 'claim' ? 'team/claim-created' : request.action === 'done' ? 'team/claim-done' : 'team/claim-released';
         if (operation.kind !== kind || !this.sameActor(operation.actor, request.actor) || operation.data.workspaceId !== request.workspaceId
@@ -2089,12 +2245,19 @@ export class AgentTeamLedger {
     }
     assertSameAttention(operation, request) {
         if (operation.kind !== 'team/thread-attention-changed' || !this.sameActor(operation.actor, request.actor)
-            || operation.data.workspaceId !== request.workspaceId || operation.data.task.taskRef !== request.taskRef || operation.data.action !== request.action)
+            || operation.data.workspaceId !== request.workspaceId
+            || (request.threadRef !== undefined && operation.data.thread.threadRef !== request.threadRef)
+            || (request.taskRef !== undefined && operation.data.task?.taskRef !== request.taskRef)
+            || (request.threadRef === undefined && request.taskRef === undefined)
+            || operation.data.action !== request.action)
             this.throwRequestCollision(request.requestId);
     }
     assertSameThreadRead(operation, request) {
         if (operation.kind !== 'team/thread-read' || !this.sameActor(operation.actor, request.actor)
-            || operation.data.workspaceId !== request.workspaceId || operation.data.task.taskRef !== request.taskRef)
+            || operation.data.workspaceId !== request.workspaceId
+            || (request.threadRef !== undefined && operation.data.thread.threadRef !== request.threadRef)
+            || (request.taskRef !== undefined && operation.data.task?.taskRef !== request.taskRef)
+            || (request.threadRef === undefined && request.taskRef === undefined))
             this.throwRequestCollision(request.requestId);
     }
     sameTask(left, right) {
@@ -2180,13 +2343,17 @@ export class AgentTeamLedger {
             task: operation.data.task, thread: operation.data.thread, claims: operation.data.claims });
     }
     attentionResult(operation) {
-        return Object.freeze({ receipt: this.receipt(operation), task: operation.data.task, thread: operation.data.thread,
+        return Object.freeze({ receipt: this.receipt(operation), ...(operation.data.task === undefined ? {} : { task: operation.data.task }), thread: operation.data.thread,
             ...(operation.data.inbox.attention.set[0] === undefined ? {} : { attention: operation.data.inbox.attention.set[0] }) });
     }
+    promotionResult(operation) {
+        return Object.freeze({ kind: 'committed', receipt: this.receipt(operation), activity: operation.data.activity,
+            task: operation.data.task, thread: operation.data.thread });
+    }
     threadReadResult(operation) {
         // Loaded records are normalized by sortedRecords(); fresh writes always carry instants.
         const { anchor, facts } = operation.data;
-        return Object.freeze({ receipt: this.receipt(operation), task: operation.data.task, thread: operation.data.thread,
+        return Object.freeze({ receipt: this.receipt(operation), ...(operation.data.task === undefined ? {} : { task: operation.data.task }), thread: operation.data.thread,
             claims: operation.data.claims, anchor, anchorMentions: operation.data.anchorMentions, facts,
             readThroughSequence: operation.data.readThroughSequence, remainingUnreadCount: operation.data.remainingUnreadCount,
             ...(operation.data.attention === undefined ? {} : { attention: operation.data.attention }),