@wowyuarm/dsh-agent-team 0.1.2 → 0.1.4

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

@@ -16,9 +16,13 @@ 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. */
+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;
@@ -278,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,
@@ -294,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);
@@ -310,36 +317,31 @@ 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, 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);
-            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));
-            if (task.resolution === 'closed')
+            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')
                 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,
             });
@@ -349,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);
@@ -364,15 +398,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')
@@ -441,13 +470,10 @@ 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')
@@ -535,13 +561,10 @@ 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.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}'`);
@@ -549,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);
@@ -557,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);
@@ -571,14 +594,9 @@ 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.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);
@@ -586,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 (this.state.channels.get(channelRef)?.workspaceId !== request.workspaceId)
                 continue;
-            if (authorized.kind === 'member' && !this.isChannelMember(task.channelRef, authorized.memberId))
+            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);
@@ -626,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,
@@ -642,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) {
@@ -658,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) {
@@ -669,28 +688,15 @@ 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' }));
             }
         }
         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() {
@@ -705,10 +711,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.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');
@@ -717,17 +720,15 @@ 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) {
         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);
@@ -769,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;
@@ -796,12 +802,12 @@ 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);
             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();
@@ -811,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),
@@ -872,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':
@@ -883,6 +896,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. */
@@ -916,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':
@@ -925,8 +942,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() {
@@ -1071,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;
         }
@@ -1080,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;
         }
@@ -1088,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'
@@ -1114,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 });
@@ -1125,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);
@@ -1243,6 +1305,7 @@ export class AgentTeamLedger {
             this.validateInboxDelta(operation.data.inbox, projection, refs, [], [], [activity]);
             return;
         }
+        assertUnhandledKind(operation);
     }
     validateInboxDelta(delta, projection, _refs, additionalThreadRefs = [], additionalMessages = [], additionalActivities = []) {
         const attentionKeys = new Set();
@@ -1463,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;
         }
@@ -1492,7 +1565,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) {
@@ -1501,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) {
@@ -1537,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);
@@ -1597,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 }),
@@ -1687,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 }));
@@ -1779,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) {
@@ -1816,28 +1893,59 @@ export class AgentTeamLedger {
             return Object.freeze({ ...task, status: this.deriveResolvedTaskStatus(task, projected.values()) });
         }));
     }
-    threadAnchor(task) {
-        return this.threadAnchorFrom(this.state, task);
-    }
-    threadAnchorFrom(projection, task) {
-        const anchor = projection.messages.find(message => message.taskRef === task.taskRef && message.topLevel);
+    /** 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,
+            ...(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(threadRef) {
+        return this.threadAnchorFrom(this.state, threadRef);
+    }
+    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) {
         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;
-        for (const message of this.state.topLevelMessages) {
-            if (this.state.channels.get(message.channelRef)?.workspaceId !== workspaceId)
+        const next = new Map();
+        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 (channelRef !== undefined && message.channelRef !== channelRef)
+            if (this.state.channels.get(task.channelRef)?.workspaceId !== workspaceId)
                 continue;
-            numbers.set(message.taskRef, next);
-            next += 1;
+            const ordinal = (next.get(task.channelRef) ?? 0) + 1;
+            next.set(task.channelRef, ordinal);
+            numbers.set(task.taskRef, ordinal);
         }
         return numbers;
     }
@@ -1921,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)
@@ -2048,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
@@ -2078,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) {
@@ -2153,14 +2327,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);
@@ -2173,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 }),