@nomix-ai/nomix-harness 0.2.5 → 0.2.6

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

@@ -0,0 +1,243 @@
+/** Strict replay fold for Agent Teams log-only events. */
+import { z } from 'zod';
+import { SessionId } from '../../../session/lib/index.js';
+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 => SessionId(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,
+    delivery: z.enum(['quiet', 'wakeup']),
+    content: z.array(contentBlockSchema),
+}).strict();
+const teamEventSelectorSchema = z.object({
+    version: nonNegativeSafeInteger,
+    teamId: teamIdSchema,
+}).loose();
+const teamMemberEventSchema = z.object({
+    version: z.literal(1),
+    teamId: teamIdSchema,
+    member: teamMemberSnapshotSchema,
+}).strict();
+const teamTaskEventSchema = z.object({
+    version: z.literal(1),
+    teamId: teamIdSchema,
+    task: teamTaskSnapshotSchema,
+}).strict();
+const teamMessageQueuedEventSchema = z.object({
+    version: z.literal(1),
+    teamId: teamIdSchema,
+    message: teamMessageSnapshotSchema,
+}).strict();
+const teamMessageDeliveredEventSchema = z.object({
+    version: z.literal(1),
+    teamId: teamIdSchema,
+    messageId: teamMessageIdSchema,
+    targetId: sessionIdSchema,
+}).strict();
+/**
+ * Construct an empty Team fold for one root Session.
+ * @param rootId - Session whose TeamId selects applicable records.
+ * @returns mutable empty replay state.
+ */
+export function emptyTeamFoldState(rootId) {
+    return {
+        id: toTeamId(rootId),
+        members: new Map(),
+        memberIdsByName: new Map(),
+        tasks: new Map(),
+        messages: new Map(),
+        delivered: new Set(),
+        nextTaskNumber: 1,
+    };
+}
+/**
+ * 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;
+    }
+}
+/**
+ * Apply one event, ignoring Team records inherited by a different root fork.
+ * @param state - mutable Team replay state.
+ * @param event - next contiguous Session event.
+ */
+export function applyTeamEvent(state, event) {
+    if (!isTeamEvent(event))
+        return;
+    const selector = parsePersisted(event.type, teamEventSelectorSchema, event.data);
+    if (selector.version !== 1) {
+        if (selector.teamId !== state.id)
+            return;
+        throw new Error(`unsupported Agent Teams event version ${String(selector.version)}`);
+    }
+    const decoded = parseCurrentTeamEvent(event);
+    if (decoded.data.teamId !== state.id)
+        return;
+    switch (decoded.type) {
+        case 'team/member': {
+            const member = decoded.data.member;
+            const prior = state.members.get(member.id);
+            const named = state.memberIdsByName.get(member.name);
+            if (named !== undefined && named !== 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`);
+                state.memberIdsByName.set(member.name, member.id);
+            }
+            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`);
+                }
+            }
+            state.members.set(member.id, member);
+            break;
+        }
+        case 'team/task': {
+            const task = decoded.data.task;
+            const prior = state.tasks.get(task.id);
+            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);
+            }
+            state.tasks.set(task.id, task);
+            break;
+        }
+        case 'team/message/queued': {
+            const message = decoded.data.message;
+            if (state.messages.has(message.id))
+                throw new Error(`team message "${message.id}" was queued twice`);
+            state.messages.set(message.id, message);
+            break;
+        }
+        case 'team/message/delivered': {
+            const queued = state.messages.get(decoded.data.messageId);
+            if (queued === undefined)
+                throw new Error(`team message "${decoded.data.messageId}" was delivered before queueing`);
+            if (queued.targetId !== decoded.data.targetId)
+                throw new Error(`team message "${decoded.data.messageId}" target changed`);
+            if (state.delivered.has(decoded.data.messageId))
+                throw new Error(`team message "${decoded.data.messageId}" was delivered twice`);
+            state.delivered.add(decoded.data.messageId);
+            break;
+        }
+        /* v8 ignore next 2 -- TeamEventType is closed and every member is handled above. */
+        default:
+            return;
+    }
+}
+/**
+ * Replay one root Session into its current Team state.
+ * @param rootId - root Session identity selecting Team-owned records.
+ * @param events - complete contiguous Session log.
+ * @returns mutable replay state at the end of the log.
+ */
+export function foldTeam(rootId, events) {
+    const state = emptyTeamFoldState(rootId);
+    for (const event of events)
+        applyTeamEvent(state, event);
+    return state;
+}
+//# sourceMappingURL=fold.js.map

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

@@ -0,0 +1,115 @@
+/** Agent Teams service façade over roster, mailbox, task, and runtime lifecycle owners. */
+import { Context, Service } from '../../../cordis/lib/index.js';
+import z from '../../../schemastery/lib/index.mjs';
+import type { Agent } from '../../../agent/lib/index.js';
+import type { TeamMembership } from './roster.ts';
+import { TeamTaskId } from './types.ts';
+import type { Config, CreateTeamTaskRequest, SendTeamMessageRequest, SendTeamMessageResult, SpawnTeammateRequest, SpawnTeammateResult, TeamMemberView, TeamTaskView, TeamWaitResult, UpdateTeamTaskRequest } from './types.ts';
+export type * from './types.ts';
+export type { TeamMembership } from './roster.ts';
+export { TeamId, TeamMessageId, TeamTaskId } from './types.ts';
+export { TeamError } from './error.ts';
+export { foldTeam } from './fold.ts';
+declare module '@nomix-ai/cordis' {
+    interface Context {
+        agentTeams: TeamService;
+    }
+}
+/** Agent Teams service backed by the exact live Lead Session log. */
+export declare class TeamService extends Service {
+    static inject: string[];
+    static Config: z<Config>;
+    /** Validated deployment limits used by every Team operation. */
+    private readonly config;
+    private readonly activity;
+    private readonly lifecycle;
+    private readonly journal;
+    private readonly roster;
+    private readonly mailbox;
+    private readonly tasks;
+    constructor(ctx: Context, config?: Config);
+    /**
+     * 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;
+    /**
+     * List the runtime-enriched roster visible to one Team member.
+     * @param agent - exact live Team member.
+     * @returns Lead and teammate rows in creation order.
+     */
+    listMembers(agent: Agent): 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.
+     */
+    spawnTeammate(caller: Agent, request: SpawnTeammateRequest): Promise<SpawnTeammateResult>;
+    /**
+     * 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.
+     */
+    sendMessage(caller: Agent, request: SendTeamMessageRequest): Promise<SendTeamMessageResult>;
+    /**
+     * Create one unowned pending task in the Team Lead log.
+     * @param caller - exact live Team member creating the task.
+     * @param request - task text, blockers, and advisory write scopes.
+     * @returns the revision-one task view.
+     */
+    createTask(caller: Agent, request: CreateTeamTaskRequest): Promise<TeamTaskView>;
+    /**
+     * Return one task, including a deleted tombstone.
+     * @param caller - exact live Team member reading the task.
+     * @param id - Team-local task identity.
+     * @returns the latest task value and derived readiness diagnostics.
+     */
+    getTask(caller: Agent, id: TeamTaskId): TeamTaskView;
+    /**
+     * List current non-deleted tasks in numeric creation order.
+     * @param caller - exact live Team member reading the board.
+     * @returns detached current task views.
+     */
+    listTasks(caller: Agent): TeamTaskView[];
+    /**
+     * Compare-and-set one authorized task transition.
+     * @param caller - exact live Team member authorizing the mutation.
+     * @param request - task identity, expected revision, action, and action fields.
+     * @returns the committed next task revision.
+     */
+    updateTask(caller: Agent, request: UpdateTeamTaskRequest): Promise<TeamTaskView>;
+    /**
+     * Wait for the next Team-domain or member-status change.
+     * @param caller - exact live Team member waiting for activity.
+     * @param timeoutMs - bounded wait duration from ten seconds through one hour.
+     * @param signal - caller cancellation for the wait only.
+     * @returns one observed change or a timeout result.
+     */
+    waitForChange(caller: Agent, timeoutMs: number, signal: AbortSignal): Promise<TeamWaitResult>;
+    /**
+     * 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';
+    };
+    /**
+     * Resolve a caller without throwing, used by scoped-tool installation and observers.
+     * @param agent - candidate exact live Agent.
+     * @returns Team membership, or undefined for non-Team subagents and stale identities.
+     */
+    tryMembership(agent: Agent): TeamMembership | undefined;
+    /** Queue one contained recovery pass after publication has unwound. */
+    private scheduleRecovery;
+    /** Reconcile roster provisioning before retrying that member's pending mailbox. */
+    private recoverFor;
+    /** Stop Team-owned live branches and release every waiter before service disposal completes. */
+    private disposeRuntime;
+}
+export default TeamService;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,205 @@
+/** Agent Teams service façade over roster, mailbox, task, and runtime lifecycle owners. */
+import { Service } from '../../../cordis/lib/index.js';
+import z from '../../../schemastery/lib/index.mjs';
+import { TeamActivity } from "./activity.js";
+import { errorMessage, TeamError } from "./error.js";
+import { TeamJournal } from "./journal.js";
+import { TeamRuntimeLifecycle } from "./lifecycle.js";
+import { TeamMailbox } from "./mailbox.js";
+import { TeamRoster } from "./roster.js";
+import { TeamTaskBoard } from "./task-board.js";
+import { TeamId } from "./types.js";
+export { TeamId, TeamMessageId, TeamTaskId } from "./types.js";
+export { TeamError } from "./error.js";
+export { foldTeam } from "./fold.js";
+const DEFAULT_MAX_MEMBERS = 8;
+const DEFAULT_MAX_TASKS = 256;
+const DEFAULT_MAX_PENDING_MESSAGES = 64;
+const DEFAULT_MAX_MESSAGE_BYTES = 65_536;
+const DEFAULT_DISPOSAL_TIMEOUT_MS = 5_000;
+/** Validate one positive safe-integer deployment limit. */
+function positiveLimit(name, value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new TeamError(`${name} must be a positive safe integer`, 'TEAM_INVALID_CONFIG');
+    }
+    return value;
+}
+/** Agent Teams service backed by the exact live Lead Session log. */
+export class TeamService extends Service {
+    static inject = ['agents', 'sessions', 'sessionPersistence', 'subagents'];
+    static Config = z.object({
+        maxMembers: z.number().step(1).min(1).default(DEFAULT_MAX_MEMBERS),
+        maxTasks: z.number().step(1).min(1).default(DEFAULT_MAX_TASKS),
+        maxPendingMessagesPerMember: z.number().step(1).min(1).default(DEFAULT_MAX_PENDING_MESSAGES),
+        maxMessageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_MESSAGE_BYTES),
+        disposalTimeoutMs: z.number().step(1).min(1).default(DEFAULT_DISPOSAL_TIMEOUT_MS),
+    });
+    /** Validated deployment limits used by every Team operation. */
+    config;
+    activity;
+    lifecycle;
+    journal;
+    roster;
+    mailbox;
+    tasks;
+    constructor(ctx, config = {}) {
+        super(ctx, 'agentTeams');
+        this.config = {
+            maxMembers: positiveLimit('maxMembers', config.maxMembers ?? DEFAULT_MAX_MEMBERS),
+            maxTasks: positiveLimit('maxTasks', config.maxTasks ?? DEFAULT_MAX_TASKS),
+            maxPendingMessagesPerMember: positiveLimit('maxPendingMessagesPerMember', config.maxPendingMessagesPerMember ?? DEFAULT_MAX_PENDING_MESSAGES),
+            maxMessageBytes: positiveLimit('maxMessageBytes', config.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES),
+            disposalTimeoutMs: positiveLimit('disposalTimeoutMs', config.disposalTimeoutMs ?? DEFAULT_DISPOSAL_TIMEOUT_MS),
+        };
+        this.activity = new TeamActivity();
+        this.lifecycle = new TeamRuntimeLifecycle(this.config.disposalTimeoutMs);
+        this.journal = new TeamJournal(ctx, (root) => { this.activity.notify(TeamId(root.id)); });
+        this.roster = new TeamRoster(ctx, this.journal, this.lifecycle, this.config.maxMembers);
+        this.mailbox = new TeamMailbox(ctx, this.journal, this.roster, this.lifecycle, this.config.maxPendingMessagesPerMember, this.config.maxMessageBytes);
+        this.tasks = new TeamTaskBoard(this.journal, this.config.maxTasks);
+        ctx.on('session/event', (session, event) => { this.mailbox.observeSessionEvent(session, event); });
+        ctx.on('agent/session-start', ({ agent }) => { this.scheduleRecovery(agent); });
+        ctx.on('agent/status', ({ agent }) => {
+            const membership = this.roster.tryMembership(agent);
+            if (membership !== undefined)
+                this.activity.notify(membership.id);
+        });
+        ctx.effect(() => () => this.disposeRuntime(), 'agentTeams.runtimeLifecycle()');
+        for (const agent of ctx.agents.list())
+            this.scheduleRecovery(agent);
+    }
+    /**
+     * 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) {
+        return this.roster.membership(agent);
+    }
+    /**
+     * List the runtime-enriched roster visible to one Team member.
+     * @param agent - exact live Team member.
+     * @returns Lead and teammate rows in creation order.
+     */
+    listMembers(agent) {
+        return this.roster.list(this.roster.membership(agent));
+    }
+    /**
+     * 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 spawnTeammate(caller, request) {
+        return await this.roster.spawn(caller, request);
+    }
+    /**
+     * 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 sendMessage(caller, request) {
+        return await this.mailbox.send(caller, request);
+    }
+    /**
+     * Create one unowned pending task in the Team Lead log.
+     * @param caller - exact live Team member creating the task.
+     * @param request - task text, blockers, and advisory write scopes.
+     * @returns the revision-one task view.
+     */
+    async createTask(caller, request) {
+        return await this.tasks.create(this.roster.membership(caller), request);
+    }
+    /**
+     * Return one task, including a deleted tombstone.
+     * @param caller - exact live Team member reading the task.
+     * @param id - Team-local task identity.
+     * @returns the latest task value and derived readiness diagnostics.
+     */
+    getTask(caller, id) {
+        return this.tasks.get(this.roster.membership(caller), id);
+    }
+    /**
+     * List current non-deleted tasks in numeric creation order.
+     * @param caller - exact live Team member reading the board.
+     * @returns detached current task views.
+     */
+    listTasks(caller) {
+        return this.tasks.list(this.roster.membership(caller));
+    }
+    /**
+     * Compare-and-set one authorized task transition.
+     * @param caller - exact live Team member authorizing the mutation.
+     * @param request - task identity, expected revision, action, and action fields.
+     * @returns the committed next task revision.
+     */
+    async updateTask(caller, request) {
+        return await this.tasks.update(caller, this.roster.membership(caller), request);
+    }
+    /**
+     * Wait for the next Team-domain or member-status change.
+     * @param caller - exact live Team member waiting for activity.
+     * @param timeoutMs - bounded wait duration from ten seconds through one hour.
+     * @param signal - caller cancellation for the wait only.
+     * @returns one observed change or a timeout result.
+     */
+    async waitForChange(caller, timeoutMs, signal) {
+        const membership = this.roster.membership(caller);
+        return await this.activity.wait(membership.id, timeoutMs, 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) {
+        return this.roster.interrupt(caller, targetName);
+    }
+    /**
+     * Resolve a caller without throwing, used by scoped-tool installation and observers.
+     * @param agent - candidate exact live Agent.
+     * @returns Team membership, or undefined for non-Team subagents and stale identities.
+     */
+    tryMembership(agent) {
+        return this.roster.tryMembership(agent);
+    }
+    /** Queue one contained recovery pass after publication has unwound. */
+    scheduleRecovery(agent) {
+        queueMicrotask(() => {
+            if (this.lifecycle.disposed)
+                return;
+            void this.recoverFor(agent).catch((error) => {
+                if (this.lifecycle.disposed)
+                    return;
+                this.ctx.logger.warn(`Agent Teams recovery for "${agent.id}" failed: ${errorMessage(error)}`);
+            });
+        });
+    }
+    /** Reconcile roster provisioning before retrying that member's pending mailbox. */
+    async recoverFor(agent) {
+        await this.roster.recoverFor(agent, this.lifecycle.signal);
+        await this.mailbox.recoverFor(agent, this.lifecycle.signal);
+    }
+    /** Stop Team-owned live branches and release every waiter before service disposal completes. */
+    async disposeRuntime() {
+        this.lifecycle.close();
+        this.activity.close();
+        const failures = [];
+        await this.lifecycle.settle(this.roster.pendingCreations(), failures);
+        await this.lifecycle.settle(this.mailbox.pendingDispatches(), failures);
+        for (const [root, childIds] of this.roster.liveChildrenByRoot()) {
+            try {
+                await this.roster.stopTeammates(root, childIds);
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        if (failures.length > 0)
+            throw new AggregateError(failures, 'Agent Teams runtime disposal failed');
+    }
+}
+export default TeamService;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+/** Package-owned relational checks for Agent Teams durable records. */
+import type { Context } from '../../../cordis/lib/index.js';
+/** Cordis companion plugin name. */
+export declare const name = "team-invariant";
+/** Invariant registry required by the companion. */
+export declare const inject: string[];
+/** Register the package invariant companion. */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

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

@@ -0,0 +1,29 @@
+/** Package-owned relational checks for Agent Teams durable records. */
+import { applyTeamEvent, foldTeam, isTeamEvent } from "./fold.js";
+const PACKAGE_NAME = '@nomix-ai/nomix-experimental-agent-team';
+/** Cordis companion plugin name. */
+export const name = 'team-invariant';
+/** Invariant registry required by the companion. */
+export const inject = ['invariants'];
+/** Validate candidate Team events against the committed prefix before append. */
+const install = Object.assign((ctx, fail) => {
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName !== 'session/event')
+            return;
+        const [session, event] = args;
+        if (!isTeamEvent(event))
+            return;
+        try {
+            const state = foldTeam(session.id, session.events);
+            applyTeamEvent(state, event);
+        }
+        catch (error) {
+            /* v8 ignore next -- the strict Team fold throws Error instances. */
+            const message = error instanceof Error ? error.message : String(error);
+            fail(`session event ${event.seq} violates the Agent Teams stream: ${message}`);
+        }
+    }, { global: true });
+}, { inject: ['sessions'] });
+/** Register the package invariant companion. */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//# sourceMappingURL=invariant.js.map

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

@@ -0,0 +1,39 @@
+/** Serialized Team transactions over the exact live Lead Session log. */
+import type { Agent } from '../../../agent/lib/index.js';
+import type { Context } from '../../../cordis/lib/index.js';
+import type { SessionEventMap, SessionId } from '../../../session/lib/index.js';
+import type { TeamFoldState } from './fold.ts';
+type MutableTeamEventType = 'team/member' | 'team/task' | 'team/message/queued' | 'team/message/delivered';
+/** Owns per-Lead transaction order and committed Team event publication. */
+export declare class TeamJournal {
+    private readonly ctx;
+    private readonly onCommit;
+    private readonly tails;
+    /**
+     * @param ctx - Team service context with the injected Session service.
+     * @param onCommit - synchronous notification after the Team event flush succeeds.
+     */
+    constructor(ctx: Context, onCommit: (root: Agent) => void);
+    /**
+     * 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: Agent): TeamFoldState;
+    /**
+     * 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.
+     */
+    transact<T>(rootId: SessionId, operation: () => Promise<T>): Promise<T>;
+    /**
+     * 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.
+     */
+    appendAndFlush<T extends MutableTeamEventType>(root: Agent, type: T, data: SessionEventMap[T]): Promise<void>;
+}
+export {};
+//# sourceMappingURL=journal.d.ts.map