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

package/lib/types/roster.d.ts

@@ -0,0 +1,113 @@
+/** Team membership, continuable-child provisioning, and roster-owned teardown. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { TeamJournal } from './journal.ts';
+import type { TeamRuntimeLifecycle } from './lifecycle.ts';
+import type { TeamState } from './projection.ts';
+import { TeamId } from './types.ts';
+import type { SpawnTeammateRequest, SpawnTeammateResult, TeamMemberView } from './types.ts';
+/** Caller identity inside one implicit Team. */
+export interface TeamMembership {
+    readonly root: Agent;
+    readonly id: TeamId;
+    readonly role: 'lead' | 'teammate';
+    readonly name: string;
+}
+/**
+ * Resolve one active Team member by model-facing name, including the Lead pseudo-row.
+ * @param root - exact live Team Lead.
+ * @param state - current Team state.
+ * @param rawName - candidate member name.
+ * @returns resolved durable id and normalized name.
+ */
+export declare function resolveActiveMember(root: Agent, state: TeamState, rawName: string): {
+    id: SessionId;
+    name: string;
+};
+/** Owns Team identities and the lifecycle of rostered continuable children. */
+export declare class TeamRoster {
+    private readonly ctx;
+    private readonly journal;
+    private readonly lifecycle;
+    private readonly maxMembers;
+    private readonly inFlightCreations;
+    /**
+     * @param ctx - Team service context with Agent, Session, persistence, and subagent services.
+     * @param journal - authoritative Lead-log transaction owner.
+     * @param lifecycle - shared Team runtime admission cutoff.
+     * @param maxMembers - maximum immutable roster entries per Team.
+     */
+    constructor(ctx: Context, journal: TeamJournal, lifecycle: TeamRuntimeLifecycle, maxMembers: number);
+    /**
+     * Resolve one exact live Agent's Team role.
+     * @param agent - exact live Agent used as the authority credential.
+     * @returns its root, Team identity, role, and model-facing name.
+     */
+    membership(agent: Agent): TeamMembership;
+    /**
+     * Resolve a caller without throwing for scoped installation and lifecycle observers.
+     * @param agent - candidate exact live Agent.
+     * @returns Team membership, or undefined for non-Team subagents and stale identities.
+     */
+    tryMembership(agent: Agent): TeamMembership | undefined;
+    /**
+     * List the runtime-enriched roster visible to one Team member.
+     * @param membership - exact caller membership resolved by this roster.
+     * @returns Lead and teammate rows in creation order.
+     */
+    list(membership: TeamMembership): TeamMemberView[];
+    /**
+     * Create one named, continuable direct child of the Team Lead.
+     * @param caller - exact live Lead Agent.
+     * @param request - immutable name, description, prompt, context mode, provider, and cancellation.
+     * @returns the active roster row.
+     */
+    spawn(caller: Agent, request: SpawnTeammateRequest): Promise<SpawnTeammateResult>;
+    /**
+     * Return admitted creation operations captured for ordered disposal.
+     * @returns detached snapshot ordered only by Set insertion.
+     */
+    pendingCreations(): readonly Promise<unknown>[];
+    /**
+     * Reconcile provisioning state when one Team member Session starts.
+     * @param agent - newly started exact live Agent.
+     * @param signal - shared runtime cancellation.
+     */
+    recoverFor(agent: Agent, signal: AbortSignal): Promise<void>;
+    /**
+     * Interrupt one live teammate turn without clearing its pending inbox.
+     * @param caller - exact live Lead Agent.
+     * @param targetName - durable teammate name.
+     * @returns the target status sampled before cancellation.
+     */
+    interrupt(caller: Agent, targetName: string): {
+        previousStatus: 'running' | 'idle' | 'inactive';
+    };
+    /**
+     * Group exact live roster children by their current Lead for runtime teardown.
+     * @returns each live Lead and the roster child ids currently in the Agent registry.
+     */
+    liveChildrenByRoot(): Map<Agent, SessionId[]>;
+    /**
+     * Release exact teammate Activations through the continuation lifecycle owner.
+     * @param root - exact live Team Lead authorizing release.
+     * @param childIds - selected roster child ids.
+     */
+    stopTeammates(root: Agent, childIds: readonly SessionId[]): Promise<void>;
+    /** Perform one creation admitted before the Team runtime disposal cutoff. */
+    private spawnAdmitted;
+    /** Flush the accepted initial inbox item before the Lead can commit `active`. */
+    private checkpointInitialPrompt;
+    /** Settle provisioning-only members from their independently durable child Sessions. */
+    private reconcileProvisioning;
+    /** Build one runtime member row after successful creation. */
+    private memberView;
+    /** Validate a never-reused model-facing teammate name. */
+    private memberName;
+    /** Append one terminal provisioning edge unless recovery already settled it. */
+    private settleProvisioning;
+    /** Whether a Session's own suffix identifies a provider-owned subagent child. */
+    private subagentDescriptor;
+}
+//# sourceMappingURL=roster.d.ts.map

package/lib/types/roster.js

@@ -0,0 +1,446 @@
+/** Team membership, continuable-child provisioning, and roster-owned teardown. */
+import { randomUUID } from 'node:crypto';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { foldSubagentDescriptor } from '@deepseek-ai/dsh-subagent';
+import { errorMessage, TeamError } from "./error.js";
+import { readPersistedSession } from "./persisted.js";
+import { messageAccepted } from "./session-message.js";
+import { TeamId } from "./types.js";
+import { requiredText } from "./validation.js";
+const MEMBER_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+/**
+ * Resolve one active Team member by model-facing name, including the Lead pseudo-row.
+ * @param root - exact live Team Lead.
+ * @param state - current Team state.
+ * @param rawName - candidate member name.
+ * @returns resolved durable id and normalized name.
+ */
+export function resolveActiveMember(root, state, rawName) {
+    const name = rawName.trim();
+    if (name === 'lead')
+        return { id: root.id, name };
+    const member = state.members.find(candidate => candidate.name === name);
+    if (member === undefined || member.phase !== 'active') {
+        throw new TeamError(`active teammate "${name}" not found`, 'TEAM_MEMBER_NOT_FOUND');
+    }
+    return { id: member.id, name };
+}
+/** Owns Team identities and the lifecycle of rostered continuable children. */
+export class TeamRoster {
+    ctx;
+    journal;
+    lifecycle;
+    maxMembers;
+    inFlightCreations = new Set();
+    /**
+     * @param ctx - Team service context with Agent, Session, persistence, and subagent services.
+     * @param journal - authoritative Lead-log transaction owner.
+     * @param lifecycle - shared Team runtime admission cutoff.
+     * @param maxMembers - maximum immutable roster entries per Team.
+     */
+    constructor(ctx, journal, lifecycle, maxMembers) {
+        this.ctx = ctx;
+        this.journal = journal;
+        this.lifecycle = lifecycle;
+        this.maxMembers = maxMembers;
+    }
+    /**
+     * Resolve one exact live Agent's Team role.
+     * @param agent - exact live Agent used as the authority credential.
+     * @returns its root, Team identity, role, and model-facing name.
+     */
+    membership(agent) {
+        const membership = this.tryMembership(agent);
+        if (membership === undefined) {
+            throw new TeamError(`agent "${agent.id}" is not a member of an active Agent Team`, 'TEAM_NOT_MEMBER');
+        }
+        return membership;
+    }
+    /**
+     * Resolve a caller without throwing for scoped installation and lifecycle observers.
+     * @param agent - candidate exact live Agent.
+     * @returns Team membership, or undefined for non-Team subagents and stale identities.
+     */
+    tryMembership(agent) {
+        if (this.ctx.agents.get(agent.id) !== agent)
+            return undefined;
+        try {
+            const parentId = agent.session.header.parentSession;
+            if (parentId !== undefined) {
+                const root = this.ctx.agents.get(parentId);
+                if (root !== undefined) {
+                    const member = this.journal.state(root).members.find(candidate => candidate.id === agent.id);
+                    if (member?.phase === 'active' || member?.phase === 'provisioning') {
+                        return { root, id: TeamId(root.id), role: 'teammate', name: member.name };
+                    }
+                    // A direct child outside the durable roster is not a teammate. Ordinary
+                    // host forks are independent roots; subagent descriptors distinguish
+                    // provider-owned workers that must not receive a nested Team identity.
+                    if (this.subagentDescriptor(agent))
+                        return undefined;
+                    return { root: agent, id: TeamId(agent.id), role: 'lead', name: 'lead' };
+                }
+            }
+            // A continuation can briefly outlive its parent during child-first teardown.
+            // Do not reinterpret that durable child as a new implicit root Team. A host-
+            // resumed ordinary fork has no descriptor in its own suffix and remains a
+            // valid new root whose inherited Team records stay outside its projected Team state.
+            if (this.subagentDescriptor(agent))
+                return undefined;
+            return { root: agent, id: TeamId(agent.id), role: 'lead', name: 'lead' };
+        }
+        catch {
+            // This method is used by lifecycle observers and teardown discovery. A
+            // malformed durable stream is surfaced by authoritative Team operations;
+            // the non-throwing probe must not veto unrelated Agent lifecycle edges.
+            return undefined;
+        }
+    }
+    /**
+     * List the runtime-enriched roster visible to one Team member.
+     * @param membership - exact caller membership resolved by this roster.
+     * @returns Lead and teammate rows in creation order.
+     */
+    list(membership) {
+        const { root } = membership;
+        const state = this.journal.state(root);
+        const result = [{
+                id: root.id,
+                name: 'lead',
+                role: 'lead',
+                status: root.status,
+                ...root.options.model === undefined ? {} : { model: root.options.model },
+                diagnostics: [],
+            }];
+        for (const member of state.members) {
+            const live = this.ctx.agents.get(member.id);
+            const model = live?.options.model ?? root.options.model;
+            result.push({
+                id: member.id,
+                name: member.name,
+                role: 'teammate',
+                status: member.phase === 'failed'
+                    ? 'failed'
+                    : member.phase === 'provisioning'
+                        ? 'provisioning'
+                        : live?.status ?? 'inactive',
+                description: member.description,
+                provider: member.provider,
+                context: member.context,
+                ...model === undefined ? {} : { model },
+                diagnostics: member.error === undefined ? [] : [member.error],
+            });
+        }
+        return result;
+    }
+    /**
+     * Create one named, continuable direct child of the Team Lead.
+     * @param caller - exact live Lead Agent.
+     * @param request - immutable name, description, prompt, context mode, provider, and cancellation.
+     * @returns the active roster row.
+     */
+    async spawn(caller, request) {
+        if (this.lifecycle.disposed)
+            throw new TeamError('Agent Teams service is disposing', 'TEAM_DISPOSED');
+        const operation = this.spawnAdmitted(caller, request);
+        this.inFlightCreations.add(operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.inFlightCreations.delete(operation);
+        }
+    }
+    /**
+     * Return admitted creation operations captured for ordered disposal.
+     * @returns detached snapshot ordered only by Set insertion.
+     */
+    pendingCreations() {
+        return [...this.inFlightCreations];
+    }
+    /**
+     * Reconcile provisioning state when one Team member Session starts.
+     * @param agent - newly started exact live Agent.
+     * @param signal - shared runtime cancellation.
+     */
+    async recoverFor(agent, signal) {
+        signal.throwIfAborted();
+        const membership = this.tryMembership(agent);
+        if (membership?.role === 'lead')
+            await this.reconcileProvisioning(membership.root, signal);
+    }
+    /**
+     * Interrupt one live teammate turn without clearing its pending inbox.
+     * @param caller - exact live Lead Agent.
+     * @param targetName - durable teammate name.
+     * @returns the target status sampled before cancellation.
+     */
+    interrupt(caller, targetName) {
+        const membership = this.membership(caller);
+        if (membership.role !== 'lead')
+            throw new TeamError('only the Team Lead can interrupt teammates', 'TEAM_LEAD_REQUIRED');
+        const state = this.journal.state(membership.root);
+        const target = resolveActiveMember(membership.root, state, targetName);
+        if (target.id === membership.root.id)
+            throw new TeamError('the Team Lead cannot interrupt itself', 'TEAM_INVALID_TARGET');
+        const live = this.ctx.agents.get(target.id);
+        if (live === undefined)
+            return { previousStatus: 'inactive' };
+        const previousStatus = live.status;
+        this.ctx.subagents.interrupt(target.id, { kind: 'ancestor', agent: caller });
+        return { previousStatus };
+    }
+    /**
+     * Group exact live roster children by their current Lead for runtime teardown.
+     * @returns each live Lead and the roster child ids currently in the Agent registry.
+     */
+    liveChildrenByRoot() {
+        const teams = new Map();
+        for (const agent of this.ctx.agents.list()) {
+            const rootId = agent.session.header.parentSession;
+            if (rootId === undefined)
+                continue;
+            const root = this.ctx.agents.get(rootId);
+            if (root === undefined
+                || !this.journal.state(root).members.some(member => member.id === agent.id))
+                continue;
+            const children = teams.get(root) ?? [];
+            children.push(agent.id);
+            teams.set(root, children);
+        }
+        return teams;
+    }
+    /**
+     * Release exact teammate Activations through the continuation lifecycle owner.
+     * @param root - exact live Team Lead authorizing release.
+     * @param childIds - selected roster child ids.
+     */
+    async stopTeammates(root, childIds) {
+        await this.lifecycle.withTimeout(this.ctx.subagents.drainContinuableChildren(root, childIds));
+    }
+    /** Perform one creation admitted before the Team runtime disposal cutoff. */
+    async spawnAdmitted(caller, request) {
+        const membership = this.membership(caller);
+        if (membership.role !== 'lead') {
+            throw new TeamError('only the Team Lead can create teammates', 'TEAM_LEAD_REQUIRED');
+        }
+        const signal = AbortSignal.any([request.signal, this.lifecycle.signal]);
+        signal.throwIfAborted();
+        const root = membership.root;
+        const name = this.memberName(request.name);
+        const description = requiredText(request.description, 'description', 200);
+        const childId = brandString(randomUUID());
+        const member = {
+            id: childId,
+            name,
+            description,
+            provider: requiredText(request.provider, 'provider', 200),
+            context: request.context,
+            phase: 'provisioning',
+        };
+        await this.journal.transact(root.id, async () => {
+            const state = this.journal.state(root);
+            if (state.members.some(member => member.name === name)) {
+                throw new TeamError(`teammate name "${name}" was already used in this Team`, 'TEAM_MEMBER_NAME_TAKEN');
+            }
+            if (state.members.length >= this.maxMembers) {
+                throw new TeamError(`Team member limit ${this.maxMembers} reached`, 'TEAM_MEMBER_LIMIT');
+            }
+            await this.journal.appendAndFlush(root, 'team/member', { version: 2, teamId: TeamId(root.id), member });
+        });
+        let started;
+        try {
+            started = await this.ctx.subagents.startContinuable({
+                childId,
+                provider: request.provider,
+                label: description,
+                request: {
+                    prompt: request.prompt,
+                    parent: root,
+                },
+                signal,
+            });
+            await this.checkpointInitialPrompt(childId, started.messageId, signal);
+        }
+        catch (error) {
+            const failed = {
+                ...member,
+                phase: 'failed',
+                error: errorMessage(error),
+            };
+            try {
+                const phase = await this.settleProvisioning(root, failed);
+                await this.stopTeammates(root, [childId]);
+                if (phase === 'active') {
+                    throw new TeamError(`teammate "${name}" became active while its creator reported failure`, 'TEAM_PROVISIONING_CONFLICT', { cause: error });
+                }
+            }
+            catch (recordError) {
+                throw new AggregateError([error, recordError], 'teammate creation and durable failure recording both failed');
+            }
+            throw error;
+        }
+        const active = {
+            ...member,
+            phase: 'active',
+        };
+        // Once the continuation accepted its first prompt, it is a real child. If
+        // this checkpoint fails, keep the in-memory active edge instead of inventing
+        // an impossible active -> failed transition; restart reconciliation covers
+        // the provisioning-only durable prefix.
+        const settledPhase = await this.settleProvisioning(root, active);
+        if (settledPhase === 'failed') {
+            const conflict = new TeamError(`teammate "${name}" was reconciled as failed while creation was in progress`, 'TEAM_PROVISIONING_CONFLICT');
+            try {
+                await this.stopTeammates(root, [childId]);
+            }
+            catch (cleanupError) {
+                /* v8 ignore next -- requires the independently tested HMR settlement conflict and cleanup failure together. */
+                throw new AggregateError([conflict, cleanupError], 'provisioning conflict cleanup failed');
+            }
+            throw conflict;
+        }
+        return { member: this.memberView(active) };
+    }
+    /** Flush the accepted initial inbox item before the Lead can commit `active`. */
+    async checkpointInitialPrompt(childId, messageId, signal) {
+        while (true) {
+            signal.throwIfAborted();
+            const session = this.ctx.sessions.get(childId);
+            if (session === undefined) {
+                const stored = await readPersistedSession(this.ctx.sessionPersistence, childId, signal);
+                const suffix = stored.events.slice(stored.inheritedEventCount);
+                if (messageAccepted(suffix, message => message.id === messageId))
+                    return;
+                throw new TeamError(`teammate "${childId}" initial prompt was not durably accepted`, 'TEAM_PROVISIONING_CONFLICT');
+            }
+            const progress = Promise.withResolvers();
+            // Abort can win while the durability flush is still pending; mark the
+            // later-awaited rejection handled without changing its eventual result.
+            void progress.promise.catch(() => undefined);
+            const stopEvent = this.ctx.on('session/event', (candidate) => {
+                if (candidate === session)
+                    progress.resolve();
+            });
+            const stopDisposed = this.ctx.on('session/disposed', (candidate) => {
+                if (candidate === session)
+                    progress.resolve();
+            });
+            const onAbort = () => {
+                const reason = signal.reason;
+                progress.reject(reason instanceof Error
+                    ? reason
+                    : new TeamError(`teammate creation aborted: ${errorMessage(reason)}`, 'TEAM_DISPOSED'));
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            try {
+                signal.throwIfAborted();
+                await this.ctx.sessions.flush(session);
+                const suffix = session.snapshotEvents(session.inheritedEventCount);
+                if (messageAccepted(suffix, message => message.id === messageId))
+                    return;
+                if (this.ctx.sessions.get(childId) !== session)
+                    continue;
+                await progress.promise;
+            }
+            finally {
+                signal.removeEventListener('abort', onAbort);
+                stopDisposed();
+                stopEvent();
+            }
+        }
+    }
+    /** Settle provisioning-only members from their independently durable child Sessions. */
+    async reconcileProvisioning(root, signal) {
+        const provisioning = this.journal.state(root).members.filter(member => member.phase === 'provisioning');
+        for (const member of provisioning) {
+            signal.throwIfAborted();
+            // A live child means creation is still completing in this process. Its
+            // creator owns the terminal member edge.
+            if (this.ctx.agents.get(member.id) !== undefined)
+                continue;
+            let phase = 'failed';
+            let failure = 'provisioning did not leave a resumable child Session';
+            try {
+                const loaded = await readPersistedSession(this.ctx.sessionPersistence, member.id, signal);
+                const suffix = loaded.events.slice(loaded.inheritedEventCount);
+                const descriptor = foldSubagentDescriptor(suffix);
+                const acceptedInitialPrompt = messageAccepted(suffix, message => message.source.kind === 'user');
+                if (loaded.header.parentSession === root.id
+                    && descriptor?.mode === 'continuable'
+                    && descriptor.provider === member.provider
+                    && acceptedInitialPrompt) {
+                    phase = 'active';
+                }
+                else {
+                    failure = 'persisted child Session does not match the provisioned continuation';
+                }
+            }
+            catch (error) {
+                failure = `child Session recovery failed: ${errorMessage(error)}`;
+            }
+            signal.throwIfAborted();
+            await this.journal.transact(root.id, async () => {
+                signal.throwIfAborted();
+                const current = this.journal.state(root).members.find(candidate => candidate.id === member.id);
+                if (current?.phase !== 'provisioning')
+                    return;
+                const settled = {
+                    ...current,
+                    phase,
+                    ...phase === 'failed' ? { error: failure } : {},
+                };
+                await this.journal.appendAndFlush(root, 'team/member', {
+                    version: 2,
+                    teamId: TeamId(root.id),
+                    member: settled,
+                });
+            });
+        }
+    }
+    /** Build one runtime member row after successful creation. */
+    memberView(member) {
+        const live = this.ctx.agents.get(member.id);
+        return {
+            id: member.id,
+            name: member.name,
+            role: 'teammate',
+            status: live?.status ?? 'inactive',
+            description: member.description,
+            provider: member.provider,
+            context: member.context,
+            ...live?.options.model === undefined ? {} : { model: live.options.model },
+            diagnostics: [],
+        };
+    }
+    /** Validate a never-reused model-facing teammate name. */
+    memberName(value) {
+        if (!MEMBER_NAME.test(value) || value.length > 64 || value === 'lead') {
+            throw new TeamError('teammate name must be lower-kebab-case, at most 64 characters, and not "lead"', 'TEAM_INVALID_MEMBER_NAME');
+        }
+        return value;
+    }
+    /** Append one terminal provisioning edge unless recovery already settled it. */
+    async settleProvisioning(root, terminal) {
+        return this.journal.transact(root.id, async () => {
+            const current = this.journal.state(root).members.find(member => member.id === terminal.id);
+            /* v8 ignore next 3 -- the append-only provisioning event is committed by this operation before settlement. */
+            if (current === undefined) {
+                throw new TeamError(`provisioned teammate "${terminal.id}" disappeared`, 'TEAM_PROVISIONING_CONFLICT');
+            }
+            if (current.phase !== 'provisioning')
+                return current.phase;
+            await this.journal.appendAndFlush(root, 'team/member', {
+                version: 2,
+                teamId: TeamId(root.id),
+                member: terminal,
+            });
+            return terminal.phase === 'active' ? 'active' : 'failed';
+        });
+    }
+    /** Whether a Session's own suffix identifies a provider-owned subagent child. */
+    subagentDescriptor(agent) {
+        return foldSubagentDescriptor(agent.session.snapshotEvents(agent.session.inheritedEventCount)) !== undefined;
+    }
+}
+//# sourceMappingURL=roster.js.map

package/lib/types/session-message.d.ts

@@ -0,0 +1,11 @@
+/** Durable Session-message acceptance checks shared by provisioning and mailbox recovery. */
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/**
+ * Test whether one message is model-visible or still durably pending.
+ * @param events - one Session's non-inherited event suffix.
+ * @param predicate - identity check for the accepted message.
+ * @returns whether history or the current inbox contains a match.
+ */
+export declare function messageAccepted(events: readonly SessionEvent[], predicate: (message: UserMessage) => boolean): boolean;
+//# sourceMappingURL=session-message.d.ts.map

package/lib/types/session-message.js

@@ -0,0 +1,23 @@
+/** Durable Session-message acceptance checks shared by provisioning and mailbox recovery. */
+/** Fold the durable inbox suffix into the messages still awaiting a claim. */
+function pendingInboxMessages(events) {
+    const inbox = { 'next-turn': [], 'next-step': [] };
+    for (const event of events) {
+        if (event.type !== 'agent/inbox/spliced')
+            continue;
+        const pending = inbox[event.data.target];
+        pending.splice(event.data.start, event.data.removedCount ?? 0, ...event.data.inserted);
+    }
+    return [...inbox['next-turn'], ...inbox['next-step']];
+}
+/**
+ * Test whether one message is model-visible or still durably pending.
+ * @param events - one Session's non-inherited event suffix.
+ * @param predicate - identity check for the accepted message.
+ * @returns whether history or the current inbox contains a match.
+ */
+export function messageAccepted(events, predicate) {
+    return events.some(event => event.type === 'user/message' && predicate(event.data))
+        || pendingInboxMessages(events).some(predicate);
+}
+//# sourceMappingURL=session-message.js.map

package/lib/types/task-board.d.ts

@@ -0,0 +1,62 @@
+/** Shared Team task DAG commands and runtime-enriched views. */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { TeamMembership } from './roster.ts';
+import type { TeamJournal } from './journal.ts';
+import { TeamTaskId } from './types.ts';
+import type { CreateTeamTaskRequest, TeamTaskView, UpdateTeamTaskRequest } from './types.ts';
+/** Owns Team task limits, authorization, transitions, and derived views. */
+export declare class TeamTaskBoard {
+    private readonly journal;
+    private readonly maxTasks;
+    /**
+     * @param journal - authoritative Lead-log transaction owner.
+     * @param maxTasks - maximum non-deleted tasks retained by one Team.
+     */
+    constructor(journal: TeamJournal, maxTasks: number);
+    /**
+     * Create one unowned pending task in the Team Lead log.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @param request - task text, blockers, and advisory write scopes.
+     * @returns the revision-one task view.
+     */
+    create(membership: TeamMembership, request: CreateTeamTaskRequest): Promise<TeamTaskView>;
+    /**
+     * Return one task, including a deleted tombstone.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @param id - Team-local task identity.
+     * @returns the latest task value and derived readiness diagnostics.
+     */
+    get(membership: TeamMembership, id: TeamTaskId): TeamTaskView;
+    /**
+     * List current non-deleted tasks in numeric creation order.
+     * @param membership - exact caller membership resolved by the Team roster.
+     * @returns detached current task views.
+     */
+    list(membership: TeamMembership): TeamTaskView[];
+    /**
+     * Compare-and-set one authorized task transition.
+     * @param caller - exact live Team member authorizing the mutation.
+     * @param membership - caller role and exact live Lead.
+     * @param request - task identity, expected revision, action, and action fields.
+     * @returns the committed next task revision.
+     */
+    update(caller: Agent, membership: TeamMembership, request: UpdateTeamTaskRequest): Promise<TeamTaskView>;
+    /** Validate and de-duplicate dependency ids against the current task graph. */
+    private dependencies;
+    /** Normalize and de-duplicate task write scopes. */
+    private writeScopes;
+    /** Map shared task-graph validation onto stable command error codes. */
+    private assertTaskGraph;
+    /** Whether all current blockers completed. */
+    private taskReady;
+    /** Remove an optional owner field under exactOptionalPropertyTypes. */
+    private withoutOwner;
+    /**
+     * Build one task view with owner name, readiness, and advisory write overlaps.
+     * A committing caller may pass its pre-append state because `task` supplies the
+     * new value explicitly; owner names, blocker readiness, and other task scopes
+     * do not change when that snapshot is appended.
+     */
+    private taskView;
+}
+//# sourceMappingURL=task-board.d.ts.map