@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/experimental-agent-team/lib/types/journal.js

@@ -0,0 +1,59 @@
+/** Serialized Team transactions over the exact live Lead Session log. */
+import { foldTeam } from "./fold.js";
+/** Owns per-Lead transaction order and committed Team event publication. */
+export class TeamJournal {
+    ctx;
+    onCommit;
+    tails = new Map();
+    /**
+     * @param ctx - Team service context with the injected Session service.
+     * @param onCommit - synchronous notification after the Team event flush succeeds.
+     */
+    constructor(ctx, onCommit) {
+        this.ctx = ctx;
+        this.onCommit = onCommit;
+    }
+    /**
+     * Fold authoritative Team state for one exact live Lead.
+     * @param root - exact live Team Lead.
+     * @returns current replay state selected by the Lead Team id.
+     */
+    state(root) {
+        return foldTeam(root.id, root.session.events);
+    }
+    /**
+     * Serialize one Lead's asynchronous mutation operation.
+     * @param rootId - Lead Session identity selecting the transaction queue.
+     * @param operation - complete read-check-append operation.
+     * @returns the operation result.
+     */
+    async transact(rootId, operation) {
+        const prior = this.tails.get(rootId) ?? Promise.resolve();
+        const run = prior.then(operation, operation);
+        const tail = run.then(() => undefined, () => undefined);
+        this.tails.set(rootId, tail);
+        try {
+            return await run;
+        }
+        finally {
+            if (this.tails.get(rootId) === tail)
+                this.tails.delete(rootId);
+        }
+    }
+    /**
+     * Append and checkpoint one root-owned Team event before publication.
+     * @param root - exact live Lead whose Session owns the event.
+     * @param type - Team event discriminant.
+     * @param data - payload correlated with the event type.
+     */
+    async appendAndFlush(root, type, data) {
+        // Team events never enter the conversation surface. This narrower local
+        // capability removes Session.append's conditional surface argument while
+        // preserving the event-key/payload correlation.
+        const append = root.session.append.bind(root.session);
+        append(type, data);
+        await this.ctx.sessions.flush(root.session);
+        this.onCommit(root);
+    }
+}
+//# sourceMappingURL=journal.js.map

package/dist/kernel/experimental-agent-team/lib/types/lifecycle.d.ts

@@ -0,0 +1,33 @@
+/** Shared admission cutoff and bounded settlement for the Team runtime. */
+/** Owns the single Team runtime cancellation fact and disposal timeout. */
+export declare class TeamRuntimeLifecycle {
+    private readonly disposalTimeoutMs;
+    private readonly controller;
+    /**
+     * @param disposalTimeoutMs - maximum wait for one disposal settlement operation.
+     */
+    constructor(disposalTimeoutMs: number);
+    /** Signal aborted exactly when Team runtime admission closes. */
+    get signal(): AbortSignal;
+    /** Whether Team runtime admission is closed. */
+    get disposed(): boolean;
+    /** The exact cancellation reason used to distinguish expected disposal rejection. */
+    get reason(): unknown;
+    /** Whether a rejection is the runtime cancellation, directly or through an Error cause chain. */
+    private isCancellation;
+    /** Close Team runtime admission and cancel admitted interruptible work. */
+    close(): void;
+    /**
+     * Await admitted operations and retain failures other than runtime cancellation.
+     * @param operations - admitted operations captured after the admission cutoff.
+     * @param failures - aggregate destination for unexpected rejection or timeout.
+     */
+    settle(operations: readonly Promise<unknown>[], failures: unknown[]): Promise<void>;
+    /**
+     * Bound one runtime settlement operation.
+     * @param operation - settlement that may otherwise block HMR or process shutdown.
+     * @returns the operation result.
+     */
+    withTimeout<T>(operation: Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/kernel/experimental-agent-team/lib/types/lifecycle.js

@@ -0,0 +1,85 @@
+/** Shared admission cutoff and bounded settlement for the Team runtime. */
+import { TeamError } from "./error.js";
+/** Owns the single Team runtime cancellation fact and disposal timeout. */
+export class TeamRuntimeLifecycle {
+    disposalTimeoutMs;
+    controller = new AbortController();
+    /**
+     * @param disposalTimeoutMs - maximum wait for one disposal settlement operation.
+     */
+    constructor(disposalTimeoutMs) {
+        this.disposalTimeoutMs = disposalTimeoutMs;
+    }
+    /** Signal aborted exactly when Team runtime admission closes. */
+    get signal() {
+        return this.controller.signal;
+    }
+    /** Whether Team runtime admission is closed. */
+    get disposed() {
+        return this.signal.aborted;
+    }
+    /** The exact cancellation reason used to distinguish expected disposal rejection. */
+    get reason() {
+        const reason = this.signal.reason;
+        return reason;
+    }
+    /** Whether a rejection is the runtime cancellation, directly or through an Error cause chain. */
+    isCancellation(reason) {
+        const seen = new Set();
+        let current = reason;
+        while (!seen.has(current)) {
+            if (this.disposed && current === this.reason)
+                return true;
+            if (this.disposed && current instanceof TeamError && current.code === 'TEAM_DISPOSED')
+                return true;
+            if (!(current instanceof Error))
+                return false;
+            seen.add(current);
+            current = current.cause;
+        }
+        return false;
+    }
+    /** Close Team runtime admission and cancel admitted interruptible work. */
+    close() {
+        this.controller.abort(new TeamError('Agent Teams service disposed', 'TEAM_DISPOSED'));
+    }
+    /**
+     * Await admitted operations and retain failures other than runtime cancellation.
+     * @param operations - admitted operations captured after the admission cutoff.
+     * @param failures - aggregate destination for unexpected rejection or timeout.
+     */
+    async settle(operations, failures) {
+        if (operations.length === 0)
+            return;
+        try {
+            const outcomes = await this.withTimeout(Promise.allSettled(operations));
+            for (const outcome of outcomes) {
+                if (outcome.status === 'rejected' && !this.isCancellation(outcome.reason))
+                    failures.push(outcome.reason);
+            }
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    /**
+     * Bound one runtime settlement operation.
+     * @param operation - settlement that may otherwise block HMR or process shutdown.
+     * @returns the operation result.
+     */
+    async withTimeout(operation) {
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                reject(new TeamError(`Agent Teams runtime disposal exceeded ${this.disposalTimeoutMs}ms`, 'TEAM_DISPOSAL_TIMEOUT'));
+            }, this.disposalTimeoutMs);
+        });
+        try {
+            return await Promise.race([operation, timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/kernel/experimental-agent-team/lib/types/mailbox.d.ts

@@ -0,0 +1,79 @@
+/** Durable Team mailbox admission, target-local dispatch, acknowledgement, and recovery. */
+import type { Context } from '../../../cordis/lib/index.js';
+import type { Agent } from '../../../agent/lib/index.js';
+import type { Session, SessionEvent } from '../../../session/lib/index.js';
+import type { TeamJournal } from './journal.ts';
+import type { TeamRuntimeLifecycle } from './lifecycle.ts';
+import type { TeamRoster } from './roster.ts';
+import type { SendTeamMessageRequest, SendTeamMessageResult } from './types.ts';
+/** Owns every process-local state transition for the durable Team mailbox. */
+export declare class TeamMailbox {
+    private readonly ctx;
+    private readonly journal;
+    private readonly roster;
+    private readonly lifecycle;
+    private readonly maxPendingMessagesPerMember;
+    private readonly maxMessageBytes;
+    private readonly dispatchTails;
+    private readonly activeDispatches;
+    private readonly inFlightMessages;
+    private readonly inFlightDispatches;
+    /**
+     * @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: Context, journal: TeamJournal, roster: TeamRoster, lifecycle: TeamRuntimeLifecycle, maxPendingMessagesPerMember: number, maxMessageBytes: number);
+    /**
+     * Queue one durable peer message, then attempt immediate delivery.
+     * @param caller - exact live sending Team member.
+     * @param request - target name, content, scheduling mode, and pre-queue cancellation.
+     * @returns durable message identity and immediate-delivery observation.
+     */
+    send(caller: Agent, request: SendTeamMessageRequest): Promise<SendTeamMessageResult>;
+    /**
+     * 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: Session, event: SessionEvent): void;
+    /**
+     * Retry durable pending messages relevant to one started Team member.
+     * @param agent - newly started exact live Agent.
+     * @param signal - shared runtime cancellation.
+     */
+    recoverFor(agent: Agent, signal: AbortSignal): Promise<void>;
+    /**
+     * Return admitted dispatch and acknowledgement operations captured for disposal.
+     * @returns detached snapshot ordered only by Set insertion.
+     */
+    pendingDispatches(): readonly Promise<unknown>[];
+    /** Queue and dispatch one mailbox item admitted before the disposal cutoff. */
+    private sendAdmitted;
+    /** Attempt one queued message exactly once in this process at a time. */
+    private tryDispatch;
+    /** Track one dispatch transaction through delivery admission or contained failure. */
+    private trackDispatch;
+    /** Attempt one queued message admitted before the service lifecycle cutoff. */
+    private tryDispatchAdmitted;
+    /** Serialize delivery admission for one durable target in queued order. */
+    private serializeDispatch;
+    /** Attempt one queued delivery after target-local ordering admits it. */
+    private dispatchOnce;
+    /** Whether `left` was durably queued before `right` in one Lead log. */
+    private messagePrecedes;
+    /** Flush one live target receipt before the Lead records its delivered edge. */
+    private checkpointDelivered;
+    /** Record delivery unless the acknowledgement already exists. */
+    private markDelivered;
+    /** Whether a target Session already contains the durable message identity. */
+    private targetRecorded;
+    /** Frame peer content with stable sender and message identity for the receiving model. */
+    private deliveryContent;
+    /** Inspect an inactive target before cold resume; uncertainty keeps the mailbox queued. */
+    private persistedTargetRecorded;
+}
+//# sourceMappingURL=mailbox.d.ts.map

package/dist/kernel/experimental-agent-team/lib/types/mailbox.js

@@ -0,0 +1,303 @@
+/** Durable Team mailbox admission, target-local dispatch, acknowledgement, and recovery. */
+import { randomUUID } from 'node:crypto';
+import { createUserMessage } from '../../../llm/lib/index.js';
+import { SessionId } from '../../../session/lib/index.js';
+import { errorMessage, TeamError } from "./error.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();
+    activeDispatches = 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, scheduling mode, 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(SessionId(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.values()].filter(message => !state.delivered.has(message.id)
+            && (membership.role === 'lead' || message.targetId === agent.id));
+        for (const message of messages) {
+            signal.throwIfAborted();
+            if (membership.role === 'lead' && message.delivery === 'quiet'
+                && message.targetId !== membership.root.id && this.ctx.agents.get(message.targetId) === undefined)
+                continue;
+            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.values()].filter(candidate => candidate.targetId === target.id && !state.delivered.has(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,
+                delivery: request.delivery,
+                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: 1,
+                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) {
+        const active = this.activeDispatches.get(message.targetId);
+        const live = message.targetId === root.id ? root : this.ctx.agents.get(message.targetId);
+        if (active !== undefined && live !== undefined && message.delivery === 'quiet'
+            && this.messagePrecedes(root, message.id, active.id)) {
+            return await this.dispatchOnce(root, message, signal);
+        }
+        return await this.serializeDispatch(message, () => this.dispatchOnce(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();
+        const dispatch = async () => {
+            this.activeDispatches.set(targetId, message);
+            try {
+                return await operation();
+            }
+            finally {
+                this.activeDispatches.delete(targetId);
+            }
+        };
+        /* v8 ignore next -- dispatch tails absorb rejection, so the recovery callback is a fail-safe backstop. */
+        const run = prior.then(dispatch, dispatch);
+        /* 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);
+        }
+    }
+    /** 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 });
+                if (message.delivery === 'wakeup') {
+                    root.followup(input);
+                    return await this.checkpointDelivered(root, root.session, message.id);
+                }
+                root.inject(input);
+                return await this.checkpointDelivered(root, root.session, message.id);
+            }
+            if (message.delivery === 'quiet') {
+                if (target === undefined)
+                    return false;
+                target.inject(createUserMessage({ content, source }));
+                return await this.checkpointDelivered(root, target.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 this.ctx.subagents.followup(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;
+        }
+    }
+    /** Whether `left` was durably queued before `right` in one Lead log. */
+    messagePrecedes(root, left, right) {
+        const ids = [...this.journal.state(root).messages.keys()];
+        return ids.indexOf(left) < ids.indexOf(right);
+    }
+    /** 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.has(messageId))
+                return;
+            const queued = state.messages.get(messageId);
+            if (queued === undefined || queued.targetId !== targetId)
+                return;
+            await this.journal.appendAndFlush(root, 'team/message/delivered', {
+                version: 1,
+                teamId: TeamId(root.id),
+                messageId,
+                targetId,
+            });
+        });
+    }
+    /** Whether a target Session already contains the durable message identity. */
+    targetRecorded(session, messageId) {
+        const suffix = session.events.slice(session.header.seedLength ?? 0);
+        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),
+        ];
+    }
+    /** Inspect an inactive target before cold resume; uncertainty keeps the mailbox queued. */
+    async persistedTargetRecorded(targetId, messageId, signal) {
+        try {
+            const stored = await this.ctx.sessionPersistence.inspect(targetId, signal);
+            const suffix = stored.events.slice(stored.meta.seedLength ?? 0);
+            return messageAccepted(suffix, message => message.source.kind === 'team-message'
+                && message.source.messageId === messageId);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`cannot inspect Team message target "${targetId}": ${errorMessage(error)}`);
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=mailbox.js.map

package/dist/kernel/experimental-agent-team/lib/types/roster.d.ts

@@ -0,0 +1,113 @@
+/** Team membership, continuable-child provisioning, and roster-owned teardown. */
+import type { Context } from '../../../cordis/lib/index.js';
+import type { Agent } from '../../../agent/lib/index.js';
+import { SessionId } from '../../../session/lib/index.js';
+import type { TeamFoldState } from './fold.ts';
+import type { TeamJournal } from './journal.ts';
+import type { TeamRuntimeLifecycle } from './lifecycle.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 fold.
+ * @param rawName - candidate member name.
+ * @returns resolved durable id and normalized name.
+ */
+export declare function resolveActiveMember(root: Agent, state: TeamFoldState, 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