@deepseek-ai/dsh-experimental-agent-team 0.1.5-alpha.2

package/lib/types/mailbox.js

@@ -0,0 +1,292 @@
+/** Durable Team mailbox admission, target-local dispatch, acknowledgement, and recovery. */
+import { randomUUID } from 'node:crypto';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { steerHostSubagentPrompt } from '@deepseek-ai/dsh-subagent/internal';
+import { errorMessage, TeamError } from "./error.js";
+import { readPersistedSession } from "./persisted.js";
+import { resolveActiveMember } from "./roster.js";
+import { messageAccepted } from "./session-message.js";
+import { TeamId, TeamMessageId } from "./types.js";
+/** Owns every process-local state transition for the durable Team mailbox. */
+export class TeamMailbox {
+    ctx;
+    journal;
+    roster;
+    lifecycle;
+    maxPendingMessagesPerMember;
+    maxMessageBytes;
+    dispatchTails = new Map();
+    inFlightMessages = new Set();
+    inFlightDispatches = new Set();
+    /**
+     * @param ctx - Team service context with Agent, Session, persistence, and subagent services.
+     * @param journal - authoritative Lead-log transaction owner.
+     * @param roster - Team membership and member-name resolver.
+     * @param lifecycle - shared Team runtime admission cutoff.
+     * @param maxPendingMessagesPerMember - per-target queued-minus-delivered limit.
+     * @param maxMessageBytes - maximum complete sender-framed delivery size.
+     */
+    constructor(ctx, journal, roster, lifecycle, maxPendingMessagesPerMember, maxMessageBytes) {
+        this.ctx = ctx;
+        this.journal = journal;
+        this.roster = roster;
+        this.lifecycle = lifecycle;
+        this.maxPendingMessagesPerMember = maxPendingMessagesPerMember;
+        this.maxMessageBytes = maxMessageBytes;
+    }
+    /**
+     * Queue one durable peer message, then attempt immediate delivery.
+     * @param caller - exact live sending Team member.
+     * @param request - target name, content, and pre-queue cancellation.
+     * @returns durable message identity and immediate-delivery observation.
+     */
+    async send(caller, request) {
+        if (this.lifecycle.disposed)
+            throw new TeamError('Agent Teams service is disposing', 'TEAM_DISPOSED');
+        const operation = this.sendAdmitted(caller, {
+            ...request,
+            signal: AbortSignal.any([request.signal, this.lifecycle.signal]),
+        });
+        return await this.trackDispatch(operation);
+    }
+    /**
+     * Observe target-side durable receipts and checkpoint their Lead-log acknowledgement.
+     * @param session - exact target Session receiving the event.
+     * @param event - newly appended Session event.
+     */
+    observeSessionEvent(session, event) {
+        if (this.lifecycle.disposed || event.type !== 'user/message' || event.data.source.kind !== 'team-message')
+            return;
+        const source = event.data.source;
+        const acknowledgement = Promise.resolve().then(async () => {
+            const root = this.ctx.agents.get(brandString(source.teamId));
+            if (root !== undefined)
+                await this.checkpointDelivered(root, session, source.messageId);
+        }).catch((error) => {
+            this.ctx.logger.warn(`Team message "${source.messageId}" acknowledgement failed: ${errorMessage(error)}`);
+        });
+        void this.trackDispatch(acknowledgement);
+    }
+    /**
+     * Retry durable pending messages relevant to one started Team member.
+     * @param agent - newly started exact live Agent.
+     * @param signal - shared runtime cancellation.
+     */
+    async recoverFor(agent, signal) {
+        signal.throwIfAborted();
+        const membership = this.roster.tryMembership(agent);
+        if (membership === undefined)
+            return;
+        const state = this.journal.state(membership.root);
+        const messages = state.messages.filter(message => !state.delivered.includes(message.id)
+            && (membership.role === 'lead' || message.targetId === agent.id));
+        for (const message of messages) {
+            signal.throwIfAborted();
+            await this.tryDispatch(membership.root, message, signal);
+        }
+    }
+    /**
+     * Return admitted dispatch and acknowledgement operations captured for disposal.
+     * @returns detached snapshot ordered only by Set insertion.
+     */
+    pendingDispatches() {
+        return [...this.inFlightDispatches];
+    }
+    /** Queue and dispatch one mailbox item admitted before the disposal cutoff. */
+    async sendAdmitted(caller, request) {
+        const membership = this.roster.membership(caller);
+        request.signal.throwIfAborted();
+        const root = membership.root;
+        const content = structuredClone(request.content);
+        const queued = await this.journal.transact(root.id, async () => {
+            request.signal.throwIfAborted();
+            const state = this.journal.state(root);
+            const target = resolveActiveMember(root, state, request.target);
+            if (target.id === caller.id)
+                throw new TeamError('a Team member cannot message itself', 'TEAM_SELF_MESSAGE');
+            const pendingForTarget = state.messages.filter(candidate => candidate.targetId === target.id && !state.delivered.includes(candidate.id)).length;
+            if (pendingForTarget >= this.maxPendingMessagesPerMember) {
+                throw new TeamError(`teammate "${target.name}" has ${pendingForTarget} pending messages`, 'TEAM_MAILBOX_FULL');
+            }
+            const queued = {
+                id: TeamMessageId(`team-message-${randomUUID()}`),
+                senderId: caller.id,
+                senderName: membership.name,
+                targetId: target.id,
+                content,
+            };
+            if (Buffer.byteLength(JSON.stringify(this.deliveryContent(queued)), 'utf8') > this.maxMessageBytes) {
+                throw new TeamError(`team message exceeds ${this.maxMessageBytes} bytes`, 'TEAM_MESSAGE_TOO_LARGE');
+            }
+            await this.journal.appendAndFlush(root, 'team/message/queued', {
+                version: 2,
+                teamId: TeamId(root.id),
+                message: queued,
+            });
+            // Register dispatch before releasing the root transaction so concurrent
+            // senders enter the target-local queue in durable mailbox order.
+            return { message: queued, dispatch: this.tryDispatch(root, queued, request.signal) };
+        });
+        const accepted = await queued.dispatch;
+        return { messageId: queued.message.id, status: accepted ? 'accepted' : 'queued' };
+    }
+    /** Attempt one queued message exactly once in this process at a time. */
+    tryDispatch(root, message, signal) {
+        if (this.lifecycle.disposed)
+            return Promise.resolve(false);
+        if (this.inFlightMessages.has(message.id))
+            return Promise.resolve(false);
+        this.inFlightMessages.add(message.id);
+        const operation = this.trackDispatch(this.tryDispatchAdmitted(root, message, AbortSignal.any([signal, this.lifecycle.signal])));
+        const forget = () => {
+            this.inFlightMessages.delete(message.id);
+        };
+        void operation.then(forget, forget);
+        return operation;
+    }
+    /** Track one dispatch transaction through delivery admission or contained failure. */
+    trackDispatch(operation) {
+        this.inFlightDispatches.add(operation);
+        void operation.then(() => {
+            this.inFlightDispatches.delete(operation);
+        }, () => {
+            this.inFlightDispatches.delete(operation);
+        });
+        return operation;
+    }
+    /** Attempt one queued message admitted before the service lifecycle cutoff. */
+    async tryDispatchAdmitted(root, message, signal) {
+        return await this.serializeDispatch(message, () => this.dispatchThrough(root, message, signal));
+    }
+    /** Serialize delivery admission for one durable target in queued order. */
+    async serializeDispatch(message, operation) {
+        const targetId = message.targetId;
+        const prior = this.dispatchTails.get(targetId) ?? Promise.resolve();
+        /* v8 ignore next -- dispatch tails absorb rejection, so the recovery callback is a fail-safe backstop. */
+        const run = prior.then(operation, operation);
+        /* v8 ignore next -- dispatchOnce contains delivery failures and serializeDispatch itself does not throw. */
+        const tail = run.then(() => undefined, () => undefined);
+        this.dispatchTails.set(targetId, tail);
+        try {
+            return await run;
+        }
+        finally {
+            if (this.dispatchTails.get(targetId) === tail)
+                this.dispatchTails.delete(targetId);
+        }
+    }
+    /** Deliver every pending target message through `message` in durable queue order. */
+    async dispatchThrough(root, message, signal) {
+        const state = this.journal.state(root);
+        const pending = state.messages.filter(candidate => candidate.targetId === message.targetId && !state.delivered.includes(candidate.id));
+        const requested = pending.findIndex(candidate => candidate.id === message.id);
+        if (requested < 0)
+            return state.delivered.includes(message.id);
+        for (const candidate of pending.slice(0, requested + 1)) {
+            const ownsInFlight = !this.inFlightMessages.has(candidate.id);
+            if (ownsInFlight)
+                this.inFlightMessages.add(candidate.id);
+            try {
+                if (!await this.dispatchOnce(root, candidate, signal))
+                    return false;
+            }
+            finally {
+                if (ownsInFlight)
+                    this.inFlightMessages.delete(candidate.id);
+            }
+        }
+        return true;
+    }
+    /** Attempt one queued delivery after target-local ordering admits it. */
+    async dispatchOnce(root, message, signal) {
+        try {
+            const target = message.targetId === root.id ? root : this.ctx.agents.get(message.targetId);
+            if (target !== undefined && this.targetRecorded(target.session, message.id)) {
+                return await this.checkpointDelivered(root, target.session, message.id);
+            }
+            const source = {
+                kind: 'team-message',
+                teamId: TeamId(root.id),
+                messageId: message.id,
+                senderId: message.senderId,
+                senderName: message.senderName,
+            };
+            const content = this.deliveryContent(message);
+            if (message.targetId === root.id) {
+                const input = createUserMessage({ content, source });
+                root.steer(input);
+                return await this.checkpointDelivered(root, root.session, message.id);
+            }
+            if (target === undefined) {
+                const recorded = await this.persistedTargetRecorded(message.targetId, message.id, signal);
+                if (recorded === undefined)
+                    return false;
+                if (recorded) {
+                    await this.markDelivered(root, message.id, message.targetId);
+                    return true;
+                }
+            }
+            await steerHostSubagentPrompt(this.ctx.subagents, root, message.targetId, content, source, signal);
+            return target === undefined
+                ? true
+                : await this.checkpointDelivered(root, target.session, message.id);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`team message "${message.id}" remains queued: ${errorMessage(error)}`);
+            return false;
+        }
+    }
+    /** Flush one live target receipt before the Lead records its delivered edge. */
+    async checkpointDelivered(root, target, messageId) {
+        await this.ctx.sessions.flush(target);
+        if (!this.targetRecorded(target, messageId))
+            return false;
+        await this.markDelivered(root, messageId, target.id);
+        return true;
+    }
+    /** Record delivery unless the acknowledgement already exists. */
+    async markDelivered(root, messageId, targetId) {
+        await this.journal.transact(root.id, async () => {
+            const state = this.journal.state(root);
+            if (state.delivered.includes(messageId))
+                return;
+            const queued = state.messages.find(message => message.id === messageId);
+            if (queued === undefined || queued.targetId !== targetId)
+                return;
+            await this.journal.appendAndFlush(root, 'team/message/delivered', {
+                version: 2,
+                teamId: TeamId(root.id),
+                messageId,
+                targetId,
+            });
+        });
+    }
+    /** Whether a target Session already contains the durable message identity. */
+    targetRecorded(session, messageId) {
+        const suffix = session.snapshotEvents(session.inheritedEventCount);
+        return messageAccepted(suffix, message => message.source.kind === 'team-message'
+            && message.source.messageId === messageId);
+    }
+    /** Frame peer content with stable sender and message identity for the receiving model. */
+    deliveryContent(message) {
+        return [
+            { type: 'text', text: `Team message ${message.id} from ${message.senderName}:` },
+            ...structuredClone(message.content),
+        ];
+    }
+    /** Read an inactive target's durable log before cold resume; uncertainty keeps the mailbox queued. */
+    async persistedTargetRecorded(targetId, messageId, signal) {
+        try {
+            const stored = await readPersistedSession(this.ctx.sessionPersistence, targetId, signal);
+            const suffix = stored.events.slice(stored.inheritedEventCount);
+            return messageAccepted(suffix, message => message.source.kind === 'team-message'
+                && message.source.messageId === messageId);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`cannot read Team message target "${targetId}": ${errorMessage(error)}`);
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=mailbox.js.map

package/lib/types/persisted.d.ts

@@ -0,0 +1,20 @@
+/** Short-lived read-handle access to persisted Team member Sessions. */
+import type { SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
+/** One persisted Session's detached header and complete committed event log. */
+export interface PersistedSessionView {
+    /** Exact fork-inherited event count paired with `header`. */
+    readonly inheritedEventCount: SessionLogOffset;
+    readonly header: SessionHeader;
+    readonly events: readonly SessionEvent[];
+}
+/**
+ * Read one stored session's header and complete event log through a
+ * short-lived read handle, closing the handle before returning.
+ * @param persistence - the durable session store.
+ * @param id - the stored session to read.
+ * @param signal - cancellation observed by open and read.
+ * @returns the stored header and every committed event.
+ */
+export declare function readPersistedSession(persistence: SessionPersistence, id: SessionId, signal: AbortSignal): Promise<PersistedSessionView>;
+//# sourceMappingURL=persisted.d.ts.map

package/lib/types/persisted.js

@@ -0,0 +1,20 @@
+/** Short-lived read-handle access to persisted Team member Sessions. */
+/**
+ * Read one stored session's header and complete event log through a
+ * short-lived read handle, closing the handle before returning.
+ * @param persistence - the durable session store.
+ * @param id - the stored session to read.
+ * @param signal - cancellation observed by open and read.
+ * @returns the stored header and every committed event.
+ */
+export async function readPersistedSession(persistence, id, signal) {
+    const handle = await persistence.open(id, 'read', { signal });
+    try {
+        const { events } = await handle.read(0, undefined, { signal });
+        return { header: handle.header, inheritedEventCount: handle.inheritedEventCount, events };
+    }
+    finally {
+        await handle.close();
+    }
+}
+//# sourceMappingURL=persisted.js.map

package/lib/types/projection.d.ts

@@ -0,0 +1,48 @@
+/** Host-only Team state projected incrementally from committed Session events. */
+import { z } from 'zod';
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { TeamId, TeamMemberSnapshot, TeamMessageId, TeamMessageSnapshot, TeamTaskSnapshot } from './types.ts';
+/** Current Team state selected by durable Team identity. */
+export interface TeamState {
+    readonly id: TeamId;
+    readonly members: TeamMemberSnapshot[];
+    readonly tasks: TeamTaskSnapshot[];
+    readonly messages: TeamMessageSnapshot[];
+    readonly delivered: TeamMessageId[];
+    nextTaskNumber: number;
+}
+/**
+ * Construct empty state for one Team identity.
+ * @param rootId - root Session identity.
+ * @returns mutable empty Team state.
+ */
+export declare function emptyTeamState(rootId: SessionId): TeamProjectionState;
+/** Checkpoint-safe state for the Team owned by the projected Session. */
+export interface TeamProjectionState extends TeamState {
+    failure?: string;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        agentTeam: TeamProjectionState;
+    }
+}
+/** Whether one event belongs to the Team domain. */
+export type TeamEventType = 'team/member' | 'team/task' | 'team/message/queued' | 'team/message/delivered';
+/** One event owned by the Team domain. */
+type TeamSessionEvent = SessionEvent<TeamEventType>;
+/**
+ * Test whether a Session event belongs to the Team domain.
+ * @param event - candidate Session event.
+ * @returns whether the event has a Team-owned type.
+ */
+export declare function isTeamEvent(event: SessionEvent): event is TeamSessionEvent;
+/** Host-only Team projection selected by the projected Session identity. */
+export declare const teamProjectionDefinition: {
+    key: "agentTeam";
+    stateVersion: number;
+    stateSchema: z.ZodType<TeamProjectionState, unknown, z.core.$ZodTypeInternals<TeamProjectionState, unknown>>;
+    init: (header: import("@deepseek-ai/dsh-session").SessionHeader) => TeamProjectionState;
+    apply: (state: NoInfer<TeamProjectionState>, event: SessionEvent) => TeamProjectionState;
+};
+export {};
+//# sourceMappingURL=projection.d.ts.map

package/lib/types/projection.js

@@ -0,0 +1,260 @@
+/** Host-only Team state projected incrementally from committed Session events. */
+import { z } from 'zod';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { TeamId as toTeamId, TeamMessageId as toTeamMessageId, TeamTaskId as toTeamTaskId, } from "./types.js";
+import { assertTaskGraphCandidate } from "./task-graph.js";
+const nonNegativeSafeInteger = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const positiveSafeInteger = nonNegativeSafeInteger.min(1);
+const sessionIdSchema = z.string().min(1).transform(value => brandString(value));
+const teamIdSchema = z.string().min(1).transform(value => toTeamId(value));
+const numericTaskIdPattern = /^task-(\d+)$/u;
+const teamTaskIdSchema = z.string().min(1).refine((value) => {
+    const match = numericTaskIdPattern.exec(value);
+    return match === null || Number.isSafeInteger(Number(match[1]));
+}, { message: 'numeric task id suffix must be a safe integer' }).transform(value => toTeamTaskId(value));
+const teamMessageIdSchema = z.string().min(1).transform(value => toTeamMessageId(value));
+const coreContentBlockTypes = new Set(['text', 'reasoning', 'image', 'tool-call', 'tool-result']);
+const imageAttachmentSchema = z.object({
+    attachmentId: z.string().min(1),
+    mediaType: z.enum(['image/png', 'image/jpeg', 'image/webp', 'image/gif']),
+    bytes: nonNegativeSafeInteger,
+    width: positiveSafeInteger,
+    height: positiveSafeInteger,
+    name: z.string().optional(),
+}).strict();
+// ContentBlockMap is merge-extensible. Validate every core variant exactly,
+// while retaining JSON-decoded plugin variants under an unknown type tag.
+const contentBlockSchema = z.lazy(() => z.union([
+    z.object({ type: z.literal('text'), text: z.string() }).strict(),
+    z.object({ type: z.literal('reasoning'), text: z.string() }).strict(),
+    z.object({ type: z.literal('image'), attachment: imageAttachmentSchema }).strict(),
+    z.object({
+        type: z.literal('tool-call'),
+        id: z.string().min(1),
+        name: z.string(),
+        arguments: z.string(),
+    }).strict(),
+    z.object({
+        type: z.literal('tool-result'),
+        toolCallId: z.string().min(1),
+        content: z.array(contentBlockSchema),
+        isError: z.boolean().optional(),
+    }).strict(),
+    z.object({ type: z.string().min(1) }).loose().refine(block => !coreContentBlockTypes.has(block.type), { message: 'known content block types must match their declared fields' }),
+]));
+const teamMemberSnapshotSchema = z.object({
+    id: sessionIdSchema,
+    name: z.string(),
+    description: z.string(),
+    provider: z.string(),
+    context: z.enum(['fresh', 'fork']),
+    phase: z.enum(['provisioning', 'active', 'failed']),
+    error: z.string().optional(),
+}).strict();
+const teamTaskSnapshotSchema = z.object({
+    id: teamTaskIdSchema,
+    revision: positiveSafeInteger,
+    subject: z.string(),
+    description: z.string(),
+    status: z.enum(['pending', 'in_progress', 'completed', 'deleted']),
+    ownerId: sessionIdSchema.optional(),
+    blockedBy: z.array(teamTaskIdSchema),
+    writeScopes: z.array(z.string()),
+}).strict();
+const teamMessageSnapshotSchema = z.object({
+    id: teamMessageIdSchema,
+    senderId: sessionIdSchema,
+    senderName: z.string(),
+    targetId: sessionIdSchema,
+    content: z.array(contentBlockSchema),
+}).strict();
+const teamEventSelectorSchema = z.object({
+    version: nonNegativeSafeInteger,
+    teamId: teamIdSchema,
+}).loose();
+const teamMemberEventSchema = z.object({
+    version: z.literal(2),
+    teamId: teamIdSchema,
+    member: teamMemberSnapshotSchema,
+}).strict();
+const teamTaskEventSchema = z.object({
+    version: z.literal(2),
+    teamId: teamIdSchema,
+    task: teamTaskSnapshotSchema,
+}).strict();
+const teamMessageQueuedEventSchema = z.object({
+    version: z.literal(2),
+    teamId: teamIdSchema,
+    message: teamMessageSnapshotSchema,
+}).strict();
+const teamMessageDeliveredEventSchema = z.object({
+    version: z.literal(2),
+    teamId: teamIdSchema,
+    messageId: teamMessageIdSchema,
+    targetId: sessionIdSchema,
+}).strict();
+/**
+ * Construct empty state for one Team identity.
+ * @param rootId - root Session identity.
+ * @returns mutable empty Team state.
+ */
+export function emptyTeamState(rootId) {
+    return {
+        id: toTeamId(rootId),
+        members: [],
+        tasks: [],
+        messages: [],
+        delivered: [],
+        nextTaskNumber: 1,
+    };
+}
+const teamProjectionEntrySchema = z.object({
+    id: teamIdSchema,
+    members: z.array(teamMemberSnapshotSchema),
+    tasks: z.array(teamTaskSnapshotSchema),
+    messages: z.array(teamMessageSnapshotSchema),
+    delivered: z.array(teamMessageIdSchema),
+    nextTaskNumber: positiveSafeInteger,
+    failure: z.string().optional(),
+}).strict();
+/**
+ * Test whether a Session event belongs to the Team domain.
+ * @param event - candidate Session event.
+ * @returns whether the event has a Team-owned type.
+ */
+export function isTeamEvent(event) {
+    return event.type === 'team/member'
+        || event.type === 'team/task'
+        || event.type === 'team/message/queued'
+        || event.type === 'team/message/delivered';
+}
+/** Decode one persisted Team value and retain the schema failure as its cause. */
+function parsePersisted(type, schema, value) {
+    try {
+        return schema.parse(value);
+    }
+    catch (error) {
+        throw new Error(`persisted Agent Teams ${type} payload is invalid`, { cause: error });
+    }
+}
+/** Decode the complete current-version payload selected by one Team event type. */
+function parseCurrentTeamEvent(event) {
+    switch (event.type) {
+        case 'team/member':
+            return { ...event, data: parsePersisted(event.type, teamMemberEventSchema, event.data) };
+        case 'team/task':
+            return { ...event, data: parsePersisted(event.type, teamTaskEventSchema, event.data) };
+        case 'team/message/queued':
+            return { ...event, data: parsePersisted(event.type, teamMessageQueuedEventSchema, event.data) };
+        case 'team/message/delivered':
+            return { ...event, data: parsePersisted(event.type, teamMessageDeliveredEventSchema, event.data) };
+        /* v8 ignore next 2 -- TeamEventType is closed and every member is handled above. */
+        default:
+            return event;
+    }
+}
+function applyProjectionEvent(state, event) {
+    if (state.failure !== undefined)
+        return;
+    if (!isTeamEvent(event))
+        return;
+    try {
+        const selector = parsePersisted(event.type, teamEventSelectorSchema, event.data);
+        if (selector.teamId !== state.id)
+            return;
+        if (selector.version !== 2) {
+            throw new Error(`unsupported Agent Teams event version ${String(selector.version)}`);
+        }
+        applyCurrentTeamEvent(state, parseCurrentTeamEvent(event));
+    }
+    catch (error) {
+        /* v8 ignore next -- the owned Team transition throws Error instances. */
+        state.failure = error instanceof Error ? error.message : String(error);
+    }
+}
+function applyCurrentTeamEvent(state, event) {
+    switch (event.type) {
+        case 'team/member': {
+            const member = event.data.member;
+            const index = state.members.findIndex(candidate => candidate.id === member.id);
+            const prior = state.members[index];
+            const named = state.members.find(candidate => candidate.name === member.name);
+            if (named !== undefined && named.id !== member.id) {
+                throw new Error(`teammate name "${member.name}" is reused by another member`);
+            }
+            if (prior === undefined) {
+                if (member.phase !== 'provisioning')
+                    throw new Error(`teammate "${member.name}" must begin provisioning`);
+            }
+            else {
+                if (prior.name !== member.name || prior.provider !== member.provider || prior.context !== member.context) {
+                    throw new Error(`teammate "${member.id}" changed immutable identity fields`);
+                }
+                if (prior.phase !== 'provisioning' || member.phase === 'provisioning') {
+                    throw new Error(`teammate "${member.name}" has an invalid ${prior.phase} -> ${member.phase} transition`);
+                }
+            }
+            if (index < 0)
+                state.members.push(member);
+            else
+                state.members[index] = member;
+            break;
+        }
+        case 'team/task': {
+            const task = event.data.task;
+            const index = state.tasks.findIndex(candidate => candidate.id === task.id);
+            const prior = state.tasks[index];
+            if (prior === undefined && task.revision !== 1) {
+                throw new Error(`team task "${task.id}" must begin at revision 1`);
+            }
+            if (prior !== undefined && task.revision !== prior.revision + 1) {
+                throw new Error(`team task "${task.id}" revision is not contiguous`);
+            }
+            assertTaskGraphCandidate(state.tasks, task);
+            const match = numericTaskIdPattern.exec(task.id);
+            if (match !== null) {
+                const number = Number(match[1]);
+                state.nextTaskNumber = Math.max(state.nextTaskNumber, number === Number.MAX_SAFE_INTEGER ? number : number + 1);
+            }
+            if (index < 0)
+                state.tasks.push(task);
+            else
+                state.tasks[index] = task;
+            break;
+        }
+        case 'team/message/queued': {
+            const message = event.data.message;
+            if (state.messages.some(candidate => candidate.id === message.id)) {
+                throw new Error(`team message "${message.id}" was queued twice`);
+            }
+            state.messages.push(message);
+            break;
+        }
+        case 'team/message/delivered': {
+            const queued = state.messages.find(message => message.id === event.data.messageId);
+            if (queued === undefined)
+                throw new Error(`team message "${event.data.messageId}" was delivered before queueing`);
+            if (queued.targetId !== event.data.targetId)
+                throw new Error(`team message "${event.data.messageId}" target changed`);
+            if (state.delivered.includes(event.data.messageId))
+                throw new Error(`team message "${event.data.messageId}" was delivered twice`);
+            state.delivered.push(event.data.messageId);
+            break;
+        }
+        /* v8 ignore next 2 -- TeamEventType is closed and every member is handled above. */
+        default:
+            return;
+    }
+}
+/** Host-only Team projection selected by the projected Session identity. */
+export const teamProjectionDefinition = {
+    key: 'agentTeam',
+    stateVersion: 3,
+    stateSchema: teamProjectionEntrySchema,
+    init: header => emptyTeamState(header.id),
+    apply: (state, event) => {
+        applyProjectionEvent(state, event);
+        return state;
+    },
+};
+//# sourceMappingURL=projection.js.map