praxis-agent 0.35.0 → 0.37.0

package/dist/core/agent-orchestration.js

@@ -0,0 +1,235 @@
+/** Provider- and persistence-independent lifecycle contract for one Agent. */
+export const TERMINAL_LIFECYCLE_STATES = [
+    'completed',
+    'failed',
+    'cancelled',
+    'orphaned',
+];
+const transitions = {
+    queued: ['running', 'cancelling', 'failed'],
+    running: ['waiting', 'completed', 'failed', 'cancelling'],
+    waiting: ['running', 'completed', 'failed', 'cancelling'],
+    cancelling: ['cancelled'],
+    completed: [],
+    failed: [],
+    cancelled: [],
+    orphaned: [],
+};
+export function isTerminalLifecycleState(state) {
+    return TERMINAL_LIFECYCLE_STATES.includes(state);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseOwner(value) {
+    if (!isRecord(value))
+        throw new Error('Invalid lifecycle owner');
+    const owner = value;
+    const token = owner.token;
+    const pid = owner.pid;
+    const acquiredAt = owner.acquiredAt;
+    if (typeof token !== 'string' ||
+        token.trim().length === 0 ||
+        !Number.isSafeInteger(pid) ||
+        Number(pid) <= 0 ||
+        typeof acquiredAt !== 'string' ||
+        Number.isNaN(Date.parse(acquiredAt))) {
+        throw new Error('Invalid lifecycle owner');
+    }
+    return Object.freeze({
+        token: token,
+        pid: pid,
+        acquiredAt: acquiredAt,
+    });
+}
+/** The single invariant parser used by every lifecycle mutation and store. */
+export function parseAgentLifecycleSnapshot(value) {
+    if (!isRecord(value))
+        throw new Error('Invalid lifecycle snapshot');
+    const generation = value.generation;
+    const revision = value.revision;
+    const state = value.state;
+    const previousOwnerToken = value.previousOwnerToken;
+    const acceptance = value.acceptance;
+    const terminalAt = value.terminalAt;
+    if (!Number.isSafeInteger(generation) || Number(generation) <= 0) {
+        throw new Error('Lifecycle generation must be a positive integer');
+    }
+    if (!Number.isSafeInteger(revision) || Number(revision) < 0) {
+        throw new Error('Lifecycle revision must be a nonnegative integer');
+    }
+    if (![
+        'queued',
+        'running',
+        'waiting',
+        'completed',
+        'failed',
+        'cancelling',
+        'cancelled',
+        'orphaned',
+    ].includes(String(state))) {
+        throw new Error(`Invalid lifecycle state: ${String(value.state)}`);
+    }
+    if (previousOwnerToken !== null &&
+        (typeof previousOwnerToken !== 'string' ||
+            previousOwnerToken.trim().length === 0)) {
+        throw new Error('Invalid previous lifecycle owner token');
+    }
+    if (!['pending', 'accepted', 'rejected'].includes(String(acceptance))) {
+        throw new Error('Invalid lifecycle acceptance');
+    }
+    if (isTerminalLifecycleState(state)) {
+        if (value.owner !== null || terminalAt === null) {
+            throw new Error('Terminal lifecycle must be ownerless and timestamped');
+        }
+        if (typeof terminalAt !== 'string' ||
+            Number.isNaN(Date.parse(terminalAt))) {
+            throw new Error('Invalid lifecycle terminal timestamp');
+        }
+        if (acceptance !== 'pending' && state !== 'completed') {
+            throw new Error('Only completed lifecycle may be accepted or rejected');
+        }
+    }
+    else if (value.owner === null ||
+        terminalAt !== null ||
+        acceptance !== 'pending') {
+        throw new Error('Nonterminal lifecycle must be owned, pending, and untimestamped');
+    }
+    const owner = value.owner === null ? null : parseOwner(value.owner);
+    return Object.freeze({
+        generation: generation,
+        revision: revision,
+        state: state,
+        owner,
+        previousOwnerToken: previousOwnerToken,
+        terminalAt: terminalAt,
+        acceptance: acceptance,
+    });
+}
+export function createAgentLifecycle(owner, generation = 1) {
+    parseOwner(owner);
+    return parseAgentLifecycleSnapshot({
+        generation,
+        revision: 0,
+        state: 'queued',
+        owner,
+        previousOwnerToken: null,
+        terminalAt: null,
+        acceptance: 'pending',
+    });
+}
+function requireCurrentOwner(current, token) {
+    if (current.owner === null || current.owner.token !== token) {
+        throw new Error('Lifecycle execution owner token is stale or missing');
+    }
+}
+export function transitionLifecycle(current, nextState, ownerToken, terminalAt = new Date().toISOString()) {
+    parseAgentLifecycleSnapshot(current);
+    requireCurrentOwner(current, ownerToken);
+    if (!transitions[current.state].includes(nextState)) {
+        throw new Error(`Illegal lifecycle transition: ${current.state} -> ${nextState}`);
+    }
+    const terminal = isTerminalLifecycleState(nextState);
+    if (terminal && Number.isNaN(Date.parse(terminalAt))) {
+        throw new Error('Invalid lifecycle terminal timestamp');
+    }
+    return parseAgentLifecycleSnapshot({
+        generation: current.generation,
+        revision: current.revision + 1,
+        state: nextState,
+        owner: terminal ? null : current.owner,
+        previousOwnerToken: terminal
+            ? (current.owner?.token ?? null)
+            : current.previousOwnerToken,
+        terminalAt: terminal ? terminalAt : null,
+        acceptance: 'pending',
+    });
+}
+function requireFreshOwner(current, owner) {
+    parseOwner(owner);
+    if (owner.token === current.previousOwnerToken) {
+        throw new Error('Lifecycle generation requires a fresh owner token');
+    }
+}
+/** Rotate a queued execution owner during a planned parent-to-worker handoff. */
+export function transferLifecycleOwner(current, currentOwnerToken, nextOwner) {
+    parseAgentLifecycleSnapshot(current);
+    requireCurrentOwner(current, currentOwnerToken);
+    if (current.state !== 'queued') {
+        throw new Error(`Cannot transfer lifecycle owner from ${current.state}`);
+    }
+    parseOwner(nextOwner);
+    if (nextOwner.token === currentOwnerToken) {
+        throw new Error('Lifecycle handoff requires a different owner token');
+    }
+    requireFreshOwner(current, nextOwner);
+    return parseAgentLifecycleSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        owner: nextOwner,
+        previousOwnerToken: currentOwnerToken,
+    });
+}
+export function continueLifecycle(current, owner) {
+    parseAgentLifecycleSnapshot(current);
+    if (!['completed', 'failed', 'cancelled'].includes(current.state)) {
+        throw new Error(`Cannot continue lifecycle from ${current.state}`);
+    }
+    requireFreshOwner(current, owner);
+    return parseAgentLifecycleSnapshot({
+        generation: current.generation + 1,
+        revision: current.revision + 1,
+        state: 'queued',
+        owner,
+        previousOwnerToken: current.previousOwnerToken,
+        terminalAt: null,
+        acceptance: 'pending',
+    });
+}
+export function recoverLifecycle(current, owner) {
+    parseAgentLifecycleSnapshot(current);
+    if (current.state !== 'orphaned') {
+        throw new Error(`Cannot recover lifecycle from ${current.state}`);
+    }
+    requireFreshOwner(current, owner);
+    return parseAgentLifecycleSnapshot({
+        generation: current.generation + 1,
+        revision: current.revision + 1,
+        state: 'queued',
+        owner,
+        previousOwnerToken: current.previousOwnerToken,
+        terminalAt: null,
+        acceptance: 'pending',
+    });
+}
+/** Adapter-proven owner loss is intentionally separate from ordinary transitions. */
+export function markLifecycleOrphaned(current, ownerToken, terminalAt = new Date().toISOString()) {
+    parseAgentLifecycleSnapshot(current);
+    requireCurrentOwner(current, ownerToken);
+    if (!['queued', 'running', 'waiting', 'cancelling'].includes(current.state)) {
+        throw new Error(`Cannot orphan lifecycle from ${current.state}`);
+    }
+    if (Number.isNaN(Date.parse(terminalAt)))
+        throw new Error('Invalid lifecycle terminal timestamp');
+    return parseAgentLifecycleSnapshot({
+        generation: current.generation,
+        revision: current.revision + 1,
+        state: 'orphaned',
+        owner: null,
+        previousOwnerToken: ownerToken,
+        terminalAt,
+        acceptance: 'pending',
+    });
+}
+export function acceptLifecycle(current, generation = current.generation, acceptance = 'accepted') {
+    parseAgentLifecycleSnapshot(current);
+    if (current.state !== 'completed' || generation !== current.generation) {
+        throw new Error('Only the completed current generation may be accepted');
+    }
+    return parseAgentLifecycleSnapshot({
+        ...current,
+        revision: current.revision + 1,
+        acceptance,
+    });
+}
+//# sourceMappingURL=agent-orchestration.js.map

package/dist/core/permission-policy.d.ts

@@ -0,0 +1,4 @@
+import type { PermissionResolver } from './runtime.js';
+/** Intersects a child resolver with its immutable parent permission ceiling. */
+export declare function composePermissionResolvers(parent: PermissionResolver, child: PermissionResolver): PermissionResolver;
+//# sourceMappingURL=permission-policy.d.ts.map

package/dist/core/permission-policy.js

@@ -0,0 +1,21 @@
+/** Intersects a child resolver with its immutable parent permission ceiling. */
+export function composePermissionResolvers(parent, child) {
+    return {
+        async resolve(call, context) {
+            const [parentDecision, childDecision] = await Promise.all([
+                parent.resolve(call, context),
+                child.resolve(call, context),
+            ]);
+            if (parentDecision.behavior === 'deny')
+                return parentDecision;
+            if (childDecision.behavior === 'deny')
+                return childDecision;
+            if (parentDecision.behavior === 'ask')
+                return parentDecision;
+            if (childDecision.behavior === 'ask')
+                return childDecision;
+            return parentDecision;
+        },
+    };
+}
+//# sourceMappingURL=permission-policy.js.map

package/dist/core/runtime.d.ts

@@ -419,6 +419,12 @@ export declare function permissionDecisionSource(decision: PermissionDecision):
 export declare function annotateAutoModePermissionOutcome<T extends PermissionDecision>(decision: T, outcome: AutoModePermissionOutcome): T;
 export declare function autoModePermissionOutcome(decision: PermissionDecision): AutoModePermissionOutcome | undefined;
 export interface AgentRunObserver {
+    toolExecutionStarted?(call: ModelToolCall): Promise<void>;
+    modelRequestCompleted?(input: {
+        usage: ModelUsage;
+        messages: readonly ModelMessage[];
+        tools: readonly ModelToolDefinition[];
+    }): Promise<void>;
     assistantCompleted(message: {
         content: string;
         thinkingBlocks?: readonly ModelThinkingBlock[];

package/dist/core/runtime.js

@@ -368,6 +368,7 @@ export class AgentRuntime {
                 let textBytes = 0;
                 const thinkingBlocks = [];
                 let turnUsage = emptyUsage();
+                let turnUsageSeen = false;
                 let streaming = false;
                 const toolCalls = [];
                 let terminalReason;
@@ -470,16 +471,20 @@ export class AgentRuntime {
                             }
                             toolCalls.push(event.call);
                             this.emit(event);
-                            toolScheduler.schedule(event.call, resolveToolSchedulingPolicy(this.options.tools, event.call));
+                            const policy = resolveToolSchedulingPolicy(this.options.tools, event.call);
+                            toolScheduler.schedule(event.call, request.observer?.toolExecutionStarted
+                                ? { ...policy, startAfterAssistant: true }
+                                : policy);
                         }
                         else if (event.type === 'terminal') {
                             activeAttemptHasPresentation = true;
                             terminalReason = event.reason;
                             this.emit(event);
                         }
-                        else {
+                        else if (event.type === 'usage') {
                             activeAttemptHasPresentation = true;
                             turnUsage = event.usage;
+                            turnUsageSeen = true;
                             this.emit(event);
                         }
                     }
@@ -528,6 +533,18 @@ export class AgentRuntime {
                     toolCalls.length > 0) {
                     return failScheduledTurn(new ModelProviderError(`Provider reported ${terminalReason} with completed tool calls`, { retryable: false }));
                 }
+                if (turnUsageSeen) {
+                    try {
+                        await request.observer?.modelRequestCompleted?.({
+                            usage: turnUsage,
+                            messages: providerRequest.messages,
+                            tools: definitions,
+                        });
+                    }
+                    catch (error) {
+                        return failScheduledTurn(error);
+                    }
+                }
                 if (request.collectMetrics) {
                     const turnApiDurationWithoutRetriesMsResolved = turnApiDurationWithoutRetriesMs ?? turnApiDurationMs;
                     durationApiWithoutRetriesMs = addApiDurationMetric(turnApiDurationWithoutRetriesMsResolved, durationApiWithoutRetriesMs, 'durationApiWithoutRetriesMs');
@@ -942,6 +959,7 @@ export class AgentRuntime {
         this.emit({ type: 'state', state: 'executing-tools' });
         context.permissionPhase = 'execute';
         context.permissionApproved = true;
+        await request.observer?.toolExecutionStarted?.(prepared);
         const toolStartedAt = performance.now();
         try {
             const result = await tools.execute(prepared, context);

package/dist/core/team-mailbox.d.ts

@@ -0,0 +1,54 @@
+export type TeamMailboxPayload = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly summary?: string;
+} | {
+    readonly kind: 'task';
+    readonly phase: 'request';
+    readonly requestId: string;
+    readonly taskId: string;
+    readonly text: string;
+} | {
+    readonly kind: 'task';
+    readonly phase: 'response';
+    readonly requestId: string;
+    readonly taskId: string;
+    readonly status: 'accepted' | 'rejected' | 'completed' | 'failed';
+    readonly text?: string;
+} | {
+    readonly kind: 'shutdown';
+    readonly phase: 'request';
+    readonly requestId: string;
+    readonly reason?: string;
+} | {
+    readonly kind: 'shutdown';
+    readonly phase: 'response';
+    readonly requestId: string;
+    readonly approved: boolean;
+    readonly reason?: string;
+} | {
+    readonly kind: 'plan';
+    readonly phase: 'request';
+    readonly requestId: string;
+    readonly plan: string;
+} | {
+    readonly kind: 'plan';
+    readonly phase: 'response';
+    readonly requestId: string;
+    readonly approved: boolean;
+    readonly feedback?: string;
+};
+export interface TeamMailboxMessage {
+    readonly version: 1;
+    readonly sequence: number;
+    readonly messageId: string;
+    readonly teamId: string;
+    readonly sender: string;
+    readonly recipients: readonly string[];
+    readonly payload: TeamMailboxPayload;
+    readonly createdAt: string;
+}
+export declare function parseTeamMailboxMessageId(value: unknown): string;
+export declare function parseTeamMailboxPayload(value: unknown): TeamMailboxPayload;
+export declare function parseTeamMailboxMessage(value: unknown): TeamMailboxMessage;
+//# sourceMappingURL=team-mailbox.d.ts.map

package/dist/core/team-mailbox.js

@@ -0,0 +1,212 @@
+import { parseTeamId } from './team-ownership.js';
+const MAX_ID_LENGTH = 300;
+const MAX_PAYLOAD_BYTES = 16 * 1024;
+const MAX_MESSAGE_BYTES = 64 * 1024;
+const ISO_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+function object(value, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+function closed(value, keys) {
+    const allowed = new Set(keys);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            throw new Error(`Unknown Team mailbox field: ${key}`);
+}
+function id(value, label) {
+    if (typeof value !== 'string' ||
+        value.trim() === '' ||
+        value !== value.trim() ||
+        value.length > MAX_ID_LENGTH ||
+        value.includes('\r') ||
+        value.includes('\n'))
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+export function parseTeamMailboxMessageId(value) {
+    return id(value, 'message ID');
+}
+function participantName(value, label) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+function body(value, label) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+function optionalBody(value, label) {
+    if (value === undefined)
+        return undefined;
+    return body(value, label);
+}
+function timestamp(value) {
+    if (typeof value !== 'string' ||
+        !ISO_PATTERN.test(value) ||
+        Number.isNaN(Date.parse(value)) ||
+        new Date(value).toISOString() !== value)
+        throw new Error('Invalid Team mailbox timestamp');
+    return value;
+}
+function freeze(value) {
+    if (typeof value === 'object' && value !== null && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+function assertSerializedBytes(value, limit, label) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined || Buffer.byteLength(serialized, 'utf8') > limit)
+        throw new Error(`${label} exceeds ${limit} UTF-8 bytes`);
+}
+export function parseTeamMailboxPayload(value) {
+    const source = object(value, 'Team mailbox payload');
+    if (source.kind === 'text') {
+        closed(source, ['kind', 'text', 'summary']);
+        const result = {
+            kind: 'text',
+            text: body(source.text, 'text message'),
+            ...(source.summary === undefined
+                ? {}
+                : { summary: body(source.summary, 'message summary') }),
+        };
+        assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+        return freeze(result);
+    }
+    if (source.kind === 'task') {
+        if (source.phase === 'request') {
+            closed(source, ['kind', 'phase', 'requestId', 'taskId', 'text']);
+            const result = {
+                kind: 'task',
+                phase: 'request',
+                requestId: id(source.requestId, 'request ID'),
+                taskId: id(source.taskId, 'task ID'),
+                text: body(source.text, 'task request text'),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+        if (source.phase === 'response') {
+            closed(source, ['kind', 'phase', 'requestId', 'taskId', 'status', 'text']);
+            if (source.status !== 'accepted' &&
+                source.status !== 'rejected' &&
+                source.status !== 'completed' &&
+                source.status !== 'failed')
+                throw new Error('Invalid task response status');
+            const text = optionalBody(source.text, 'task response text');
+            const result = {
+                kind: 'task',
+                phase: 'response',
+                requestId: id(source.requestId, 'request ID'),
+                taskId: id(source.taskId, 'task ID'),
+                status: source.status,
+                ...(text === undefined ? {} : { text }),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+    }
+    if (source.kind === 'shutdown') {
+        if (source.phase === 'request') {
+            closed(source, ['kind', 'phase', 'requestId', 'reason']);
+            const reason = optionalBody(source.reason, 'shutdown reason');
+            const result = {
+                kind: 'shutdown',
+                phase: 'request',
+                requestId: id(source.requestId, 'request ID'),
+                ...(reason === undefined ? {} : { reason }),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+        if (source.phase === 'response') {
+            closed(source, ['kind', 'phase', 'requestId', 'approved', 'reason']);
+            if (typeof source.approved !== 'boolean')
+                throw new Error('Invalid shutdown approval');
+            const reason = optionalBody(source.reason, 'shutdown reason');
+            const result = {
+                kind: 'shutdown',
+                phase: 'response',
+                requestId: id(source.requestId, 'request ID'),
+                approved: source.approved,
+                ...(reason === undefined ? {} : { reason }),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+    }
+    if (source.kind === 'plan') {
+        if (source.phase === 'request') {
+            closed(source, ['kind', 'phase', 'requestId', 'plan']);
+            const result = {
+                kind: 'plan',
+                phase: 'request',
+                requestId: id(source.requestId, 'request ID'),
+                plan: body(source.plan, 'plan'),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+        if (source.phase === 'response') {
+            closed(source, ['kind', 'phase', 'requestId', 'approved', 'feedback']);
+            if (typeof source.approved !== 'boolean')
+                throw new Error('Invalid plan approval');
+            const feedback = optionalBody(source.feedback, 'plan feedback');
+            const result = {
+                kind: 'plan',
+                phase: 'response',
+                requestId: id(source.requestId, 'request ID'),
+                approved: source.approved,
+                ...(feedback === undefined ? {} : { feedback }),
+            };
+            assertSerializedBytes(result, MAX_PAYLOAD_BYTES, 'Team mailbox payload');
+            return freeze(result);
+        }
+    }
+    throw new Error('Invalid Team mailbox payload variant');
+}
+export function parseTeamMailboxMessage(value) {
+    const source = object(value, 'Team mailbox message');
+    closed(source, [
+        'version',
+        'sequence',
+        'messageId',
+        'teamId',
+        'sender',
+        'recipients',
+        'payload',
+        'createdAt',
+    ]);
+    if (source.version !== 1)
+        throw new Error('Invalid Team mailbox version');
+    if (!Number.isSafeInteger(source.sequence) ||
+        source.sequence <= 0)
+        throw new Error('Invalid Team mailbox sequence');
+    const messageId = id(source.messageId, 'message ID');
+    const teamId = parseTeamId(source.teamId);
+    const sender = participantName(source.sender, 'sender');
+    if (!Array.isArray(source.recipients) || source.recipients.length === 0)
+        throw new Error('Invalid Team mailbox recipients');
+    const recipients = source.recipients.map((entry) => participantName(entry, 'recipient'));
+    if (new Set(recipients).size !== recipients.length)
+        throw new Error('Duplicate Team mailbox recipient');
+    const payload = parseTeamMailboxPayload(source.payload);
+    const createdAt = timestamp(source.createdAt);
+    const result = {
+        version: 1,
+        sequence: source.sequence,
+        messageId,
+        teamId,
+        sender,
+        recipients: freeze(recipients),
+        payload,
+        createdAt,
+    };
+    assertSerializedBytes(result, MAX_MESSAGE_BYTES, 'Team mailbox message');
+    return freeze(result);
+}
+//# sourceMappingURL=team-mailbox.js.map

package/dist/core/team-ownership.d.ts

@@ -0,0 +1,84 @@
+import { type AgentLifecycleSnapshot } from './agent-orchestration.js';
+export type TeamMemberAccess = 'read-only' | 'write';
+export type TeamLeadPolicy = 'hybrid' | 'coordinator';
+export type TeamExecutionPolicy = 'sequential' | 'swarm';
+export type TeamCommitPolicy = 'lead';
+export interface TeamBudgets {
+    readonly maxAgents: number;
+    readonly maxConcurrent: number;
+    readonly maxTokens: number;
+    readonly maxDurationMs: number;
+    readonly shutdownDrainMs: number;
+}
+export interface TeamUsage {
+    readonly totalTokens: number;
+    readonly durationMs: number;
+    readonly exhausted: null | {
+        readonly reason: 'tokens' | 'duration';
+        readonly at: string;
+    };
+}
+export declare const DEFAULT_TEAM_BUDGETS: TeamBudgets;
+export interface TeamMember {
+    readonly name: string;
+    readonly agentType: string;
+    readonly access: TeamMemberAccess;
+}
+export interface TeamTaskClaims {
+    readonly files: readonly string[];
+    readonly publicContracts: readonly string[];
+    readonly generatedArtifacts: readonly string[];
+    readonly migrations: readonly string[];
+    readonly mergeTargets: readonly string[];
+}
+export interface TeamTask {
+    readonly id: string;
+    readonly description: string;
+    readonly assignee: string;
+    readonly blockedBy: readonly string[];
+    readonly claims: TeamTaskClaims;
+    readonly execution: AgentLifecycleSnapshot | null;
+    readonly usage: {
+        readonly generation: number;
+        readonly totalTokens: number;
+        readonly durationMs: number;
+    };
+}
+export interface TeamSnapshot {
+    readonly version: 2;
+    readonly revision: number;
+    readonly teamId: string;
+    readonly name: string;
+    readonly projectIdentity: string;
+    readonly leadSessionId: string;
+    readonly roster: readonly TeamMember[];
+    readonly tasks: readonly TeamTask[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly policy: {
+        readonly lead: TeamLeadPolicy;
+        readonly execution: TeamExecutionPolicy;
+        readonly commit: TeamCommitPolicy;
+    };
+    readonly budgets: TeamBudgets;
+    readonly usage: TeamUsage;
+}
+export interface TeamAdmissionInput {
+    readonly snapshot: TeamSnapshot;
+    readonly maxConcurrent: number;
+}
+export declare function parseTeamId(value: unknown): string;
+export declare function parseTeamBudgetOverrides(value: unknown): Readonly<Partial<TeamBudgets>>;
+export declare function parseTeamSnapshot(value: unknown): TeamSnapshot;
+export declare function teamTasksConflict(left: TeamTask, right: TeamTask): boolean;
+export declare function selectTeamTaskAdmissions(input: TeamAdmissionInput): readonly string[];
+export declare function withTeamTaskExecution(snapshot: TeamSnapshot, taskId: string, execution: AgentLifecycleSnapshot): TeamSnapshot;
+export declare function acceptTeamTaskExecution(snapshot: TeamSnapshot, taskId: string, generation?: number, acceptance?: 'accepted' | 'rejected'): TeamSnapshot;
+export declare function recordTeamTaskProgress(snapshot: TeamSnapshot, taskId: string, progress: {
+    generation: number;
+    totalTokens: number;
+    durationMs: number;
+}, exhaustedAt?: string): TeamSnapshot;
+export declare function updateTeamUsageDuration(snapshot: TeamSnapshot, durationMs: number, exhaustedAt?: string): TeamSnapshot;
+export declare function markTeamBudgetExhausted(snapshot: TeamSnapshot, reason: 'tokens' | 'duration', at?: string): TeamSnapshot;
+//# sourceMappingURL=team-ownership.d.ts.map