af-motion 0.0.0-stage → 1.0.0

package/dist/core/advanced-motion/validation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Advanced Composition Validation & Dependency Analysis
+ *
+ * Validates composition syntax, timing constraints, dependency completeness,
+ * and detects circular dependency graphs using Depth-First Search (DFS).
+ */
+import type { AdvancedMotionCompositionDefinition, CompositionValidationResult } from "./types.js";
+/**
+ * Validates an advanced motion composition and analyzes its dependency graph.
+ */
+export declare function validateAdvancedComposition(definition: AdvancedMotionCompositionDefinition): CompositionValidationResult;

package/dist/core/agent-workflows/agent-registry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AF Motion — Agent Registry (Phase 18, Prompt 144)
+ *
+ * Provides a modular, thread-safe registry for discovering, registering,
+ * inspecting, and querying specialized AI Agents in AF Motion.
+ */
+import type { AgentCapability, AgentCategory, AgentDefinition, AgentInputType, AgentMetadata } from "./types.js";
+export declare class AgentRegistry {
+    private readonly agents;
+    register(agent: AgentDefinition): void;
+    unregister(agentId: string): boolean;
+    get(agentId: string): AgentDefinition | undefined;
+    has(agentId: string): boolean;
+    list(): AgentMetadata[];
+    findByCategory(category: AgentCategory): AgentDefinition[];
+    findByCapability(capability: AgentCapability): AgentDefinition[];
+    findByInputType(inputType: AgentInputType): AgentDefinition[];
+    clear(): void;
+    get size(): number;
+}
+export declare const agentRegistry: AgentRegistry;

package/dist/core/agent-workflows/agents/accessibility-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Accessibility Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for evaluating WCAG motion guidelines,
+ * verifying prefers-reduced-motion fallback compatibility, detecting
+ * vestibular triggers or excessive flashing, and recommending accessible alternatives.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const accessibilityAgent: AgentDefinition;

package/dist/core/agent-workflows/agents/composition-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Composition Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for analyzing composition graphs,
+ * identifying dependency conflicts, verifying track timing synchronizations,
+ * and recommending sequencing improvements.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const compositionAgent: AgentDefinition;

package/dist/core/agent-workflows/agents/design-to-motion-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Design-to-Motion Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for interpreting visual design briefs,
+ * structured UI components, and generating production-ready AF Motion configurations
+ * and Motion DNA profiles using Prompt 142's engine.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const designToMotionAgent: AgentDefinition;

package/dist/core/agent-workflows/agents/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AF Motion — Specialized Agents Index & Registration (Phase 18, Prompt 144)
+ */
+import { AgentRegistry } from "../agent-registry.js";
+import { motionIntelligenceAgent } from "./motion-intelligence-agent.js";
+import { designToMotionAgent } from "./design-to-motion-agent.js";
+import { sceneGenerationAgent } from "./scene-generation-agent.js";
+import { performanceOptimizationAgent } from "./performance-agent.js";
+import { accessibilityAgent } from "./accessibility-agent.js";
+import { compositionAgent } from "./composition-agent.js";
+export { motionIntelligenceAgent, designToMotionAgent, sceneGenerationAgent, performanceOptimizationAgent, accessibilityAgent, compositionAgent, };
+export declare const STANDARD_AGENTS: import("../types.js").AgentDefinition<unknown, unknown>[];
+export declare function registerDefaultAgents(registry?: AgentRegistry): void;

package/dist/core/agent-workflows/agents/motion-intelligence-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Motion Intelligence Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for analyzing motion configurations,
+ * evaluating quality scores, detecting aesthetic and timing issues,
+ * and recommending actionable improvements using Prompt 141's intelligence engine.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const motionIntelligenceAgent: AgentDefinition;

package/dist/core/agent-workflows/agents/performance-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Performance Optimization Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for analyzing runtime telemetry,
+ * identifying framerate drops and memory bottlenecks, and recommending
+ * adaptive quality scaling and GPU optimizations.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const performanceOptimizationAgent: AgentDefinition;

package/dist/core/agent-workflows/agents/scene-generation-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion — Scene Generation Agent (Phase 18, Prompt 144)
+ *
+ * Specialized agent responsible for interpreting natural-language scene requests
+ * and structured scene specifications to generate complete multi-system scenes
+ * (3D, physics, particles, DOM) using Prompt 143's engine.
+ */
+import type { AgentDefinition } from "../types.js";
+export declare const sceneGenerationAgent: AgentDefinition;

package/dist/core/agent-workflows/collaboration-planner.d.ts

@@ -0,0 +1,38 @@
+/**
+ * AF Motion — Multi-Agent Collaboration Planner (Phase 18, Prompt 145)
+ *
+ * Constructs validated collaboration plans, matches required capabilities to agents,
+ * resolves dependency graphs, detects cycles, and calculates parallel execution waves.
+ */
+import type { AgentCapability, AgentMetadata } from "./types.js";
+import type { CollaborationPlan, CollaborationTask, OrchestrationStrategy } from "./orchestration-types.js";
+import { AgentRegistry } from "./agent-registry.js";
+export declare class CollaborationPlanner {
+    private readonly registry;
+    constructor(registry?: AgentRegistry);
+    /**
+     * Automatically select the best agent for a given required capability.
+     */
+    selectAgentForCapability(capability: AgentCapability): AgentMetadata;
+    /**
+     * Group tasks into parallel execution waves based on dependency levels.
+     */
+    computeParallelWaves(tasks: CollaborationTask[]): string[][];
+    /**
+     * Validates a collaboration plan.
+     */
+    validateCollaborationPlan(plan: CollaborationPlan): {
+        valid: boolean;
+        issues: string[];
+    };
+    /**
+     * Creates a structured collaboration plan.
+     */
+    createCollaborationPlan(goal: string, tasks: Omit<CollaborationTask, "status" | "waveIndex">[], options?: {
+        strategy?: OrchestrationStrategy;
+        coordinatorAgentId?: string;
+        requirePlanApproval?: boolean;
+        metadata?: Record<string, unknown>;
+    }): CollaborationPlan;
+}
+export declare const collaborationPlanner: CollaborationPlanner;

package/dist/core/agent-workflows/collaboration-workflows.d.ts

@@ -0,0 +1,83 @@
+/**
+ * AF Motion — Specialized Multi-Agent Collaboration Workflows (Phase 18, Prompt 145)
+ *
+ * Implements 4 practical multi-agent collaboration workflows:
+ * 1. Complete Design-to-Motion Pipeline (Review-and-Refine)
+ * 2. Complete Scene Creation (Hierarchical)
+ * 3. Motion Optimization Team (Pipeline)
+ * 4. Complete Creative Audit (Parallel)
+ */
+import type { CollaborationPlan } from "./orchestration-types.js";
+import { CollaborationPlanner } from "./collaboration-planner.js";
+export declare const COLLABORATION_WORKFLOW_DEFINITIONS: {
+    "complete-design-to-motion": {
+        id: string;
+        name: string;
+        description: string;
+        strategy: "review-and-refine";
+        defaultGoal: string;
+        estimatedDurationMs: number;
+        createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+    };
+    "complete-scene-creation": {
+        id: string;
+        name: string;
+        description: string;
+        strategy: "hierarchical";
+        defaultGoal: string;
+        estimatedDurationMs: number;
+        createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+    };
+    "motion-optimization-team": {
+        id: string;
+        name: string;
+        description: string;
+        strategy: "pipeline";
+        defaultGoal: string;
+        estimatedDurationMs: number;
+        createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+    };
+    "complete-creative-audit": {
+        id: string;
+        name: string;
+        description: string;
+        strategy: "parallel";
+        defaultGoal: string;
+        estimatedDurationMs: number;
+        createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+    };
+};
+export declare function listCollaborationWorkflows(): ({
+    id: string;
+    name: string;
+    description: string;
+    strategy: "review-and-refine";
+    defaultGoal: string;
+    estimatedDurationMs: number;
+    createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+} | {
+    id: string;
+    name: string;
+    description: string;
+    strategy: "hierarchical";
+    defaultGoal: string;
+    estimatedDurationMs: number;
+    createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+} | {
+    id: string;
+    name: string;
+    description: string;
+    strategy: "pipeline";
+    defaultGoal: string;
+    estimatedDurationMs: number;
+    createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+} | {
+    id: string;
+    name: string;
+    description: string;
+    strategy: "parallel";
+    defaultGoal: string;
+    estimatedDurationMs: number;
+    createPlan: (goal: string, initialInputs?: Record<string, unknown>, planner?: CollaborationPlanner) => CollaborationPlan;
+})[];
+export declare function getCollaborationWorkflow(id: string): any;

package/dist/core/agent-workflows/communication.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AF Motion — Agent Communication Protocol & Message Bus (Phase 18, Prompt 145)
+ *
+ * Provides a structured, typed message bus for inter-agent communication,
+ * message delivery, audit trails, and security validation (no executable code).
+ */
+import type { AgentMessage, AgentMessageType } from "./orchestration-types.js";
+export declare const MAX_MESSAGE_PAYLOAD_BYTES: number;
+export declare const MAX_BUS_HISTORY_MESSAGES = 1000;
+export declare class AgentMessageBus {
+    private readonly messages;
+    private sequenceCounter;
+    private readonly subscribers;
+    createMessage(params: {
+        workflowId: string;
+        senderAgentId: string;
+        recipientAgentId: string;
+        type: AgentMessageType;
+        payload: Record<string, unknown>;
+        payloadReference?: string;
+    }): AgentMessage;
+    dispatch(message: AgentMessage): void;
+    subscribe(handler: (msg: AgentMessage) => void): () => void;
+    getMessagesForWorkflow(workflowId: string): AgentMessage[];
+    getMessagesBetween(agentA: string, agentB: string): AgentMessage[];
+    clear(): void;
+    private assertPayloadSafety;
+}
+export declare const agentMessageBus: AgentMessageBus;

package/dist/core/agent-workflows/conflict-resolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AF Motion — Multi-Agent Conflict Detection & Resolution (Phase 18, Prompt 145)
+ *
+ * Implements deterministic conflict detection across agent outputs,
+ * priority/rule-based resolutions, and transparent decision audit logging.
+ */
+import type { ConflictRecord, ResolutionStrategy } from "./orchestration-types.js";
+export declare class ConflictResolver {
+    /**
+     * Analyzes two or more agent outputs / recommendations for mutual contradictions.
+     */
+    detectConflicts(params: {
+        workflowId: string;
+        agentOutputs: Array<{
+            agentId: string;
+            output: Record<string, unknown>;
+            artifactKey?: string;
+        }>;
+    }): ConflictRecord[];
+    /**
+     * Resolves a conflict using a specified strategy or user selection.
+     */
+    resolveConflict(conflict: ConflictRecord, strategy: ResolutionStrategy, manualSelection?: unknown): ConflictRecord;
+}
+export declare const conflictResolver: ConflictResolver;

package/dist/core/agent-workflows/context.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AF Motion — Workflow Context & Audit Manager (Phase 18, Prompt 144)
+ *
+ * Implements workflow-scoped context stores, immutable output tracking,
+ * and structured audit logs for full execution observability.
+ */
+import type { AgentWorkflowTelemetry, ToolCallLog, WorkflowAuditEntry, WorkflowStatus } from "./types.js";
+export declare class WorkflowContext {
+    readonly workflowId: string;
+    readonly goal: string;
+    private readonly store;
+    private readonly taskOutputs;
+    private readonly auditTrail;
+    private readonly toolCalls;
+    private readonly startTime;
+    private endTime?;
+    private status;
+    constructor(workflowId: string, goal: string, initialData?: Record<string, unknown>);
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    getAll(): Record<string, unknown>;
+    setTaskOutput(taskId: string, output: unknown): void;
+    getTaskOutput<T = unknown>(taskId: string): T | undefined;
+    getAllTaskOutputs(): Record<string, unknown>;
+    recordToolCall(log: ToolCallLog): void;
+    logAudit(entry: Omit<WorkflowAuditEntry, "timestamp">): void;
+    getAuditTrail(): WorkflowAuditEntry[];
+    setStatus(status: WorkflowStatus): void;
+    getStatus(): WorkflowStatus;
+    getTelemetry(taskCounts: {
+        total: number;
+        completed: number;
+        failed: number;
+        skipped: number;
+    }): AgentWorkflowTelemetry;
+}

package/dist/core/agent-workflows/execution-engine.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AF Motion — Agent Workflow Execution Engine (Phase 18, Prompt 144)
+ *
+ * Implements the core execution lifecycle for agent workflows:
+ * - Topological dependency resolution
+ * - Human approval boundaries (plan-level & task-level)
+ * - Safe tool invocation via SafeToolRegistry
+ * - Retry policies and task skipping
+ * - AbortSignal cancellation & timeouts
+ * - Complete execution telemetry and audit logging
+ */
+import type { TaskPlan, WorkflowExecutionOptions, WorkflowExecutionResult } from "./types.js";
+import { AgentRegistry } from "./agent-registry.js";
+import { SafeToolRegistry } from "./tool-registry.js";
+import { TaskPlanner } from "./task-planner.js";
+export declare class WorkflowExecutionEngine {
+    private readonly agents;
+    private readonly tools;
+    private readonly planner;
+    constructor(agents?: AgentRegistry, tools?: SafeToolRegistry, planner?: TaskPlanner);
+    /**
+     * Executes a task plan asynchronously with full lifecycle support.
+     */
+    executePlan(plan: TaskPlan, options?: WorkflowExecutionOptions): Promise<WorkflowExecutionResult>;
+    /**
+     * Synchronous execution wrapper for deterministic offline testing.
+     */
+    executePlanSync(plan: TaskPlan, options?: WorkflowExecutionOptions): WorkflowExecutionResult;
+}
+export declare const workflowExecutionEngine: WorkflowExecutionEngine;

package/dist/core/agent-workflows/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AF Motion — Agent Workflows & Multi-Agent Orchestration (Phase 18, Prompts 144–145)
+ *
+ * Deterministic, offline-capable AI Agent Workflow & Multi-Agent Orchestration ecosystem.
+ */
+export { AGENT_WORKFLOWS_SPEC_VERSION, type AgentCategory, type AgentCapability, type AgentInputType, type AgentOutputType, type TaskStatus, type WorkflowStatus, type AgentMetadata, type ToolCallLog, type AgentExecutionContext, type AgentExecutionResult, type AgentDefinition, type AgentTask, type TaskPlan, type ToolPermission, type ToolDefinition, type WorkflowAuditEntry, type AgentWorkflowTelemetry, type WorkflowTemplate, type WorkflowExecutionOptions, type WorkflowExecutionResult, } from "./types.js";
+export { ORCHESTRATION_SPEC_VERSION, type OrchestrationStrategy, type AgentMessageType, type AgentMessage, type CollaborationTask, type CollaborationPlan, type SharedArtifact, type ConflictType, type ResolutionStrategy, type ConflictRecord, type QualityGateStatus, type QualityGateCheck, type CollectiveValidationResult, type MultiAgentDeliverable, type OrchestrationOptions, } from "./orchestration-types.js";
+export { AgentRegistry, agentRegistry, } from "./agent-registry.js";
+export { SafeToolRegistry, safeToolRegistry, registerDefaultSafeTools, } from "./tool-registry.js";
+export { STANDARD_AGENTS, registerDefaultAgents, motionIntelligenceAgent, designToMotionAgent, sceneGenerationAgent, performanceOptimizationAgent, accessibilityAgent, compositionAgent, } from "./agents/index.js";
+export { TaskPlanner, taskPlanner, TaskPlanValidationError, } from "./task-planner.js";
+export { WorkflowContext, } from "./context.js";
+export { SharedWorkflowContext, } from "./shared-context.js";
+export { WorkflowExecutionEngine, workflowExecutionEngine, } from "./execution-engine.js";
+export { WORKFLOW_TEMPLATES, listWorkflowTemplates, getWorkflowTemplate, } from "./templates.js";
+export { CollaborationPlanner, collaborationPlanner, } from "./collaboration-planner.js";
+export { AgentMessageBus, agentMessageBus, } from "./communication.js";
+export { ConflictResolver, conflictResolver, } from "./conflict-resolver.js";
+export { MultiAgentOrchestrator, multiAgentOrchestrator, } from "./orchestrator.js";
+export { COLLABORATION_WORKFLOW_DEFINITIONS, listCollaborationWorkflows, getCollaborationWorkflow, } from "./collaboration-workflows.js";

package/dist/core/agent-workflows/orchestration-types.d.ts

@@ -0,0 +1,144 @@
+/**
+ * AF Motion — Multi-Agent Collaboration & Orchestration Types (Phase 18, Prompt 145)
+ *
+ * Core data contracts for coordinated multi-agent orchestration, communication protocols,
+ * shared artifact stores, conflict resolution, parallel wave scheduling, and collective quality gates.
+ */
+import type { AgentCapability, AgentMetadata, AgentOutputType, TaskStatus, WorkflowStatus } from "./types.js";
+export declare const ORCHESTRATION_SPEC_VERSION = "1.0.0";
+export type OrchestrationStrategy = "sequential" | "parallel" | "hierarchical" | "pipeline" | "review-and-refine";
+export type AgentMessageType = "task_assignment" | "task_completion" | "artifact_delivery" | "analysis_findings" | "recommendations" | "validation_results" | "clarification_request" | "failure_notification" | "approval_request";
+export interface AgentMessage {
+    readonly id: string;
+    readonly workflowId: string;
+    readonly senderAgentId: string;
+    readonly recipientAgentId: string;
+    readonly type: AgentMessageType;
+    readonly sequenceNumber: number;
+    readonly timestamp: number;
+    readonly payloadReference?: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly schemaVersion: string;
+}
+export interface CollaborationTask {
+    id: string;
+    description: string;
+    assignedAgentId: string;
+    requiredCapabilities: AgentCapability[];
+    inputReferences: Record<string, string>;
+    inputs: Record<string, unknown>;
+    expectedOutput: AgentOutputType;
+    dependencies: string[];
+    priority: number;
+    status: TaskStatus;
+    waveIndex?: number;
+    optional?: boolean;
+    requireApproval?: boolean;
+    retryPolicy?: {
+        maxRetries: number;
+        retryCount: number;
+    };
+    validationRequirements?: string[];
+    output?: unknown;
+    artifactKey?: string;
+    error?: string;
+    executionDurationMs?: number;
+}
+export interface CollaborationPlan {
+    readonly workflowId: string;
+    readonly goal: string;
+    readonly strategy: OrchestrationStrategy;
+    readonly coordinatorAgentId: string;
+    readonly participatingAgentIds: readonly string[];
+    readonly tasks: readonly CollaborationTask[];
+    readonly parallelWaves: readonly (readonly string[])[];
+    readonly createdAt: number;
+    readonly estimatedDurationMs: number;
+    readonly requirePlanApproval?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface SharedArtifact<T = unknown> {
+    readonly key: string;
+    readonly version: number;
+    readonly type: AgentOutputType;
+    readonly producerAgentId: string;
+    readonly taskId: string;
+    readonly createdAt: number;
+    readonly immutable: boolean;
+    readonly data: T;
+    readonly hash: string;
+    readonly tags?: readonly string[];
+}
+export type ConflictType = "conflicting_config" | "incompatible_recommendation" | "token_mismatch" | "performance_vs_quality" | "accessibility_violation" | "dependency_cycle";
+export type ResolutionStrategy = "priority_based" | "rule_based" | "dependency_aware" | "human_approval" | "reject_with_explanation";
+export interface ConflictRecord {
+    readonly id: string;
+    readonly workflowId: string;
+    readonly conflictType: ConflictType;
+    readonly participatingAgentIds: readonly string[];
+    readonly conflictingArtifactKeys: readonly string[];
+    readonly details: string;
+    readonly resolutionStrategy: ResolutionStrategy;
+    readonly selectedResolution?: unknown;
+    readonly reason: string;
+    readonly approvalStatus: "pending" | "approved" | "rejected" | "auto_resolved";
+    readonly resolvedAt?: number;
+}
+export type QualityGateStatus = "passed" | "failed" | "warning" | "not_evaluated";
+export interface QualityGateCheck {
+    readonly id: string;
+    readonly name: string;
+    readonly required: boolean;
+    readonly status: QualityGateStatus;
+    readonly summary: string;
+    readonly evaluatedByAgentId?: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface CollectiveValidationResult {
+    readonly passed: boolean;
+    readonly gates: readonly QualityGateCheck[];
+    readonly overallQualityScore: number;
+    readonly issues: readonly string[];
+    readonly warnings: readonly string[];
+}
+export interface MultiAgentDeliverable {
+    readonly workflowId: string;
+    readonly goal: string;
+    readonly strategy: OrchestrationStrategy;
+    readonly status: WorkflowStatus;
+    readonly plan: CollaborationPlan;
+    readonly participatingAgents: readonly AgentMetadata[];
+    readonly artifacts: Readonly<Record<string, SharedArtifact>>;
+    readonly consolidatedDeliverable?: unknown;
+    readonly qualityValidation: CollectiveValidationResult;
+    readonly conflicts: readonly ConflictRecord[];
+    readonly messageAudit: readonly AgentMessage[];
+    readonly telemetry: {
+        readonly startTime: number;
+        readonly endTime: number;
+        readonly durationMs: number;
+        readonly waveCount: number;
+        readonly tasksCompleted: number;
+        readonly tasksFailed: number;
+        readonly messagesSent: number;
+    };
+    readonly error?: string;
+}
+export interface OrchestrationOptions {
+    strategy?: OrchestrationStrategy;
+    maxConcurrency?: number;
+    requirePlanApproval?: boolean;
+    requireConflictApproval?: boolean;
+    approvalGranted?: boolean;
+    onApprovalRequired?: (request: {
+        scope: "plan" | "task";
+        workflowId: string;
+        taskId?: string;
+        description: string;
+    }) => boolean | Promise<boolean>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: number, currentWave: number, activeTasks: CollaborationTask[]) => void;
+    onMessage?: (message: AgentMessage) => void;
+    onConflict?: (conflict: ConflictRecord) => void;
+}

package/dist/core/agent-workflows/orchestrator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AF Motion — Multi-Agent Orchestration Engine (Phase 18, Prompt 145)
+ *
+ * Coordinates multi-agent collaboration execution across parallel waves,
+ * message dispatching, shared artifact exchange, conflict resolution,
+ * collective quality gate validation, and final deliverable assembly.
+ */
+import type { CollaborationPlan, MultiAgentDeliverable, OrchestrationOptions } from "./orchestration-types.js";
+import { AgentRegistry } from "./agent-registry.js";
+import { SafeToolRegistry } from "./tool-registry.js";
+import { CollaborationPlanner } from "./collaboration-planner.js";
+import { AgentMessageBus } from "./communication.js";
+import { ConflictResolver } from "./conflict-resolver.js";
+export declare class MultiAgentOrchestrator {
+    private readonly agents;
+    private readonly tools;
+    private readonly planner;
+    private readonly bus;
+    private readonly conflicts;
+    constructor(agents?: AgentRegistry, tools?: SafeToolRegistry, planner?: CollaborationPlanner, bus?: AgentMessageBus, conflicts?: ConflictResolver);
+    /**
+     * Executes a multi-agent collaboration plan with wave scheduling and conflict resolution.
+     */
+    orchestrate(plan: CollaborationPlan, options?: OrchestrationOptions): Promise<MultiAgentDeliverable>;
+    private executeSingleCollaborationTask;
+    private evaluateCollectiveQualityGates;
+    private synthesizeConsolidatedDeliverable;
+}
+export declare const multiAgentOrchestrator: MultiAgentOrchestrator;

package/dist/core/agent-workflows/react.d.ts

@@ -0,0 +1,71 @@
+/**
+ * AF Motion — Agent Workflows & Collaboration React Integration (Phase 18, Prompts 144–145)
+ *
+ * Provides:
+ * - `useAgentWorkflow()`: Hook for individual agent workflows (Prompt 144)
+ * - `useAgentCollaboration()`: Hook for multi-agent orchestration, conflict resolution, and quality gates (Prompt 145)
+ */
+import type { AgentMetadata, AgentTask, TaskPlan, WorkflowAuditEntry, WorkflowExecutionOptions, WorkflowExecutionResult, WorkflowStatus, WorkflowTemplate } from "./types.js";
+import type { AgentMessage, CollaborationPlan, CollaborationTask, ConflictRecord, MultiAgentDeliverable, OrchestrationOptions, QualityGateCheck, ResolutionStrategy } from "./orchestration-types.js";
+import { listCollaborationWorkflows } from "./collaboration-workflows.js";
+export interface UseAgentWorkflowState {
+    status: WorkflowStatus;
+    isExecuting: boolean;
+    isWaitingForApproval: boolean;
+    progress: number;
+    currentTask: AgentTask | null;
+    tasks: AgentTask[];
+}
+export interface UseAgentWorkflowReturn {
+    workflowState: UseAgentWorkflowState;
+    plan: TaskPlan | null;
+    result: WorkflowExecutionResult | null;
+    error: string | null;
+    logs: WorkflowAuditEntry[];
+    availableAgents: AgentMetadata[];
+    availableTemplates: WorkflowTemplate[];
+    availableTools: Array<{
+        id: string;
+        name: string;
+        description: string;
+        permission: string;
+    }>;
+    loadTemplate: (templateId: string, initialInputs?: Record<string, unknown>) => TaskPlan | null;
+    createCustomPlan: (goal: string, tasks: Array<Omit<AgentTask, "status">>) => TaskPlan | null;
+    approvePlan: () => Promise<WorkflowExecutionResult | null>;
+    approveTask: (taskId: string) => void;
+    rejectTask: (taskId: string, reason: string) => void;
+    runWorkflow: (options?: WorkflowExecutionOptions) => Promise<WorkflowExecutionResult | null>;
+    cancelWorkflow: () => void;
+    reset: () => void;
+}
+export declare function useAgentWorkflow(defaultTemplateId?: string): UseAgentWorkflowReturn;
+export interface UseAgentCollaborationState {
+    status: WorkflowStatus;
+    isOrchestrating: boolean;
+    isWaitingForApproval: boolean;
+    progress: number;
+    currentWave: number;
+    totalWaves: number;
+    activeTasks: CollaborationTask[];
+    conflicts: ConflictRecord[];
+    qualityGates: QualityGateCheck[];
+}
+export interface UseAgentCollaborationReturn {
+    collaborationState: UseAgentCollaborationState;
+    plan: CollaborationPlan | null;
+    deliverable: MultiAgentDeliverable | null;
+    messages: AgentMessage[];
+    error: string | null;
+    availableWorkflows: ReturnType<typeof listCollaborationWorkflows>;
+    loadWorkflow: (workflowId: string, initialInputs?: Record<string, unknown>) => CollaborationPlan | null;
+    createCustomCollaboration: (goal: string, tasks: Array<Omit<CollaborationTask, "status" | "waveIndex">>, options?: {
+        strategy?: CollaborationPlan["strategy"];
+        coordinatorAgentId?: string;
+    }) => CollaborationPlan | null;
+    resolveConflict: (conflictId: string, strategy: ResolutionStrategy, manualSelection?: unknown) => void;
+    orchestrate: (options?: OrchestrationOptions) => Promise<MultiAgentDeliverable | null>;
+    cancel: () => void;
+    reset: () => void;
+}
+export declare function useAgentCollaboration(defaultWorkflowId?: string): UseAgentCollaborationReturn;